From 55df1bcf78d32be3150649de10d4334332c7303e Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Sun, 8 Apr 2012 23:03:26 +0100 Subject: [PATCH 01/13] Add new Javascript observer Output render progress onto the rendered map using Javascript A minimum period between updates can be specified --- overviewer_core/data/js_src/util.js | 4 + overviewer_core/data/js_src/views.js | 21 +++- .../data/web_assets/overviewer.css | 2 +- overviewer_core/observer.py | 96 +++++++++++++++++++ overviewer_core/settingsDefinition.py | 2 +- 5 files changed, 122 insertions(+), 3 deletions(-) diff --git a/overviewer_core/data/js_src/util.js b/overviewer_core/data/js_src/util.js index 0e738da..3d6c36e 100644 --- a/overviewer_core/data/js_src/util.js +++ b/overviewer_core/data/js_src/util.js @@ -58,6 +58,10 @@ overviewer.util = { var coordsdiv = new overviewer.views.CoordboxView({tagName: 'DIV'}); coordsdiv.render(); + var progressdiv = new overviewer.views.ProgressView({tagName: 'DIV'}); + progressdiv.render(); + progressdiv.updateProgress(); + if (overviewer.collections.haveSigns) { var signs = new overviewer.views.SignControlView(); signs.registerEvents(signs); diff --git a/overviewer_core/data/js_src/views.js b/overviewer_core/data/js_src/views.js index 323c1fc..cbc6453 100644 --- a/overviewer_core/data/js_src/views.js +++ b/overviewer_core/data/js_src/views.js @@ -108,7 +108,26 @@ overviewer.views.CoordboxView = Backbone.View.extend({ } }); - +overviewer.views.ProgressView = Backbone.View.extend({ + initialize: function() { + this.el.id = 'progressDiv'; + this.el.innerHTML = 'Current Render Progress'; + overviewer.map.controls[google.maps.ControlPosition.BOTTOM_RIGHT].push(this.el); + this.hidden = true; + }, + updateProgress: function() { + e = this; + $.getJSON('progress.js', null, function(d){ + e.el.hidden = false; + e.el.innerHTML = d['message']; + if (d.update > 0) { + setTimeout("e.updateProgress()", d.update); + } else { + e.el.hidden = true; + } + }); + } +}); /* GoogleMapView is responsible for dealing with the GoogleMaps API to create the */ diff --git a/overviewer_core/data/web_assets/overviewer.css b/overviewer_core/data/web_assets/overviewer.css index 0ae76e5..e1f1527 100644 --- a/overviewer_core/data/web_assets/overviewer.css +++ b/overviewer_core/data/web_assets/overviewer.css @@ -86,7 +86,7 @@ body { } -#link, #coordsDiv { +#link, #coordsDiv, #progressDiv { background-color: #fff; /* fallback */ background-color: rgba(255,255,255,0.55); border: 1px solid rgb(0, 0, 0); diff --git a/overviewer_core/observer.py b/overviewer_core/observer.py index c58a0d9..15cb6d7 100644 --- a/overviewer_core/observer.py +++ b/overviewer_core/observer.py @@ -17,6 +17,7 @@ import time import logging import progressbar import sys +import os class Observer(object): """Base class that defines the observer interface. @@ -164,3 +165,98 @@ class ProgressBarObserver(progressbar.ProgressBar, Observer): def _need_update(self): return self.get_current_value() - self.last_update > self.UPDATE_INTERVAL + +class JSObserver(Observer): + """Display progress on index.html using JavaScript + """ + + def __init__(self, outputdir, minrefresh=5): + """Initialise observer + outputdir must be set to the map output directory path + minrefresh specifies the minimum gap between requests, in seconds + """ + self.last_update = -11 + self.last_update_time = -1 + self._current_value = -1 + self.minrefresh = 1000*minrefresh + self.logfile = os.path.join(outputdir, "progress.js") + + f = open(self.logfile, "w", 0) + f.write('{"message": "Render in progress", "update": %d}' % self.minrefresh) + f.close() + + def start(self, max_value): + f = open(self.logfile, "w", 0) + f.write('{"message": "Rendering %d tiles", "update": %s}' % (max_value, self.minrefresh) + self.start_time=time.time() + self._set_max_value(max_value) + + def is_started(self): + return self.start_time is not None + + def finish(self): + """Signals the end of the processes, should be called after the + process is done. + """ + self.end_time = time.time() + duration = self.end_time - self.start_time + f = open(self.logfile, "w", 0) + f.write('{"message": "Render completed in %dm %ds", "update": "false"}' % (duration//60, duration - duration//60)) + f.close() + + def is_finished(self): + return self.end_time is not None + + def is_running(self): + return self.is_started() and not self.is_finished() + + def add(self, amount): + """Shortcut to update by increments instead of absolute values. Zero + amounts are ignored. + """ + if amount: + self.update(self.get_current_value() + amount) + + def update(self, current_value): + """Set the progress value. Should be between 0 and max_value. Returns + whether this update is actually displayed. + """ + self._current_value = current_value + if self._need_update(): + refresh = max(1500*(time.time() - self.last_update_time), self.minrefresh) + f = open(self.logfile, "w", 0) + f.write('{"message": "Rendered %d of %d tiles (%d%%)", "update": %d }' % (self.get_current_value(), self.get_max_value(), self.get_percentage(), refresh)) + f.close() + self.last_update_time = time.time() + self.last_update = current_value + return True + return False + + def get_percentage(self): + """Get the current progress percentage. Assumes 100% if max_value is 0 + """ + if self.get_max_value() is 0: + return 100.0 + else: + return self.get_current_value() * 100.0 / self.get_max_value() + + def get_current_value(self): + return self._current_value + + def get_max_value(self): + return self._max_value + + def _set_max_value(self, max_value): + self._max_value = max_value + + def _need_update(self): + cur_val = self.get_current_value() + if (time.time() - self.last_update_time) <= self.minrefresh//1000: + return False + if cur_val < 100: + return cur_val - self.last_update > 10 + elif cur_val < 500: + return cur_val - self.last_update > 50 + else: + return cur_val - self.last_update > 100 + diff --git a/overviewer_core/settingsDefinition.py b/overviewer_core/settingsDefinition.py index d2e357c..cfb6539 100644 --- a/overviewer_core/settingsDefinition.py +++ b/overviewer_core/settingsDefinition.py @@ -45,7 +45,7 @@ from settingsValidators import * import util -from observer import ProgressBarObserver, LoggingObserver +from observer import ProgressBarObserver, LoggingObserver, JSObserver import platform import sys From 8ec3518eb223b583330a043124cb740dc13b4e95 Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Sun, 8 Apr 2012 23:09:45 +0100 Subject: [PATCH 02/13] Fix missing bracket in observer.py --- overviewer_core/observer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/overviewer_core/observer.py b/overviewer_core/observer.py index 15cb6d7..e6fa14f 100644 --- a/overviewer_core/observer.py +++ b/overviewer_core/observer.py @@ -187,7 +187,7 @@ class JSObserver(Observer): def start(self, max_value): f = open(self.logfile, "w", 0) - f.write('{"message": "Rendering %d tiles", "update": %s}' % (max_value, self.minrefresh) + f.write('{"message": "Rendering %d tiles", "update": %s}' % (max_value, self.minrefresh)) self.start_time=time.time() self._set_max_value(max_value) From ed01a3cf07d981432192d814b548c037f0ed1c23 Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Mon, 9 Apr 2012 00:23:15 +0100 Subject: [PATCH 03/13] Minor tweaks for JSObserver --- overviewer_core/data/js_src/views.js | 1 + overviewer_core/observer.py | 6 ------ 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/overviewer_core/data/js_src/views.js b/overviewer_core/data/js_src/views.js index cbc6453..e66267e 100644 --- a/overviewer_core/data/js_src/views.js +++ b/overviewer_core/data/js_src/views.js @@ -114,6 +114,7 @@ overviewer.views.ProgressView = Backbone.View.extend({ this.el.innerHTML = 'Current Render Progress'; overviewer.map.controls[google.maps.ControlPosition.BOTTOM_RIGHT].push(this.el); this.hidden = true; + $.ajaxSetup({cache: false}); }, updateProgress: function() { e = this; diff --git a/overviewer_core/observer.py b/overviewer_core/observer.py index e6fa14f..32053cd 100644 --- a/overviewer_core/observer.py +++ b/overviewer_core/observer.py @@ -181,10 +181,6 @@ class JSObserver(Observer): self.minrefresh = 1000*minrefresh self.logfile = os.path.join(outputdir, "progress.js") - f = open(self.logfile, "w", 0) - f.write('{"message": "Render in progress", "update": %d}' % self.minrefresh) - f.close() - def start(self, max_value): f = open(self.logfile, "w", 0) f.write('{"message": "Rendering %d tiles", "update": %s}' % (max_value, self.minrefresh)) @@ -251,8 +247,6 @@ class JSObserver(Observer): def _need_update(self): cur_val = self.get_current_value() - if (time.time() - self.last_update_time) <= self.minrefresh//1000: - return False if cur_val < 100: return cur_val - self.last_update > 10 elif cur_val < 500: From c7fd50bd2d8473fa284809c76036b30a916c15b3 Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Wed, 18 Apr 2012 20:48:49 +0100 Subject: [PATCH 04/13] Add documentation for JSObserver Adds documentation for JSObserver and updates documentation for the observer option in general --- docs/config.rst | 33 +++++++++++++++++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-) diff --git a/docs/config.rst b/docs/config.rst index dac2c12..2e4e70b 100644 --- a/docs/config.rst +++ b/docs/config.rst @@ -165,6 +165,8 @@ the form ``key = value``. Two items take a different form:, ``worlds`` and **You must specify at least one render** +.. _outputdir: + ``outputdir = ""`` This is the path to the output directory where the rendered tiles will be saved. @@ -199,11 +201,38 @@ the form ``key = value``. Two items take a different form:, ``worlds`` and observer to be used. The observer object is expected to have at least ``start``, ``add``, ``update``, and ``finish`` methods. - e.g.:: + If you want to specify an observer manually, try something like: + :: + from observer import ProgressBarObserver() observer = ProgressBarObserver() -.. _outputdir: + There are currently three observers available: ``LoggingObserver``, + ``ProgressBarObserver`` and ``JSObserver``. + + ``LoggingObserver`` + This gives the normal/older style output and is the default when output + is redirected to a file or when running on Windows + + ``ProgressBarObserver`` + This is used by default when the output is a terminal. Displays a text based + progress bar and some statistics. + + ``JSObserver`` + This will display render progress on the output map in the bottom right + corner of the screen. ``JSObserver`` must be invoked with two parameters. + + The first is output directory. For simplicity, specify this as ``outputdir`` + and place this line after setting ``outputdir = ""``. + + The second parameter is the minimum interval between progress updates in + seconds. Progress information won't be written to file or requested by + your web browser more frequently than this interval. + :: + + from observer import JSObserver + observer = JSObserver(outputdir, 10) + .. _renderdict: From 806e517e98d78d7ed3098cd8c64a53b7c89e666a Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Wed, 18 Apr 2012 21:39:21 +0100 Subject: [PATCH 05/13] Fix tab/spaces in observer.py --- overviewer_core/observer.py | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/overviewer_core/observer.py b/overviewer_core/observer.py index 32053cd..f6c0bfb 100644 --- a/overviewer_core/observer.py +++ b/overviewer_core/observer.py @@ -172,20 +172,20 @@ class JSObserver(Observer): def __init__(self, outputdir, minrefresh=5): """Initialise observer - outputdir must be set to the map output directory path - minrefresh specifies the minimum gap between requests, in seconds - """ - self.last_update = -11 - self.last_update_time = -1 - self._current_value = -1 - self.minrefresh = 1000*minrefresh + outputdir must be set to the map output directory path + minrefresh specifies the minimum gap between requests, in seconds + """ + self.last_update = -11 + self.last_update_time = -1 + self._current_value = -1 + self.minrefresh = 1000*minrefresh self.logfile = os.path.join(outputdir, "progress.js") def start(self, max_value): f = open(self.logfile, "w", 0) - f.write('{"message": "Rendering %d tiles", "update": %s}' % (max_value, self.minrefresh)) + f.write('{"message": "Rendering %d tiles", "update": %s}' % (max_value, self.minrefresh)) self.start_time=time.time() - self._set_max_value(max_value) + self._set_max_value(max_value) def is_started(self): return self.start_time is not None @@ -195,9 +195,9 @@ class JSObserver(Observer): process is done. """ self.end_time = time.time() - duration = self.end_time - self.start_time + duration = self.end_time - self.start_time f = open(self.logfile, "w", 0) - f.write('{"message": "Render completed in %dm %ds", "update": "false"}' % (duration//60, duration - duration//60)) + f.write('{"message": "Render completed in %dm %ds", "update": "false"}' % (duration//60, duration - duration//60)) f.close() def is_finished(self): @@ -221,11 +221,11 @@ class JSObserver(Observer): if self._need_update(): refresh = max(1500*(time.time() - self.last_update_time), self.minrefresh) f = open(self.logfile, "w", 0) - f.write('{"message": "Rendered %d of %d tiles (%d%%)", "update": %d }' % (self.get_current_value(), self.get_max_value(), self.get_percentage(), refresh)) + f.write('{"message": "Rendered %d of %d tiles (%d%%)", "update": %d }' % (self.get_current_value(), self.get_max_value(), self.get_percentage(), refresh)) f.close() self.last_update_time = time.time() - self.last_update = current_value - return True + self.last_update = current_value + return True return False def get_percentage(self): From 62322b452aeafa28fca24fe48156e3769b0fcfae Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Wed, 18 Apr 2012 22:04:19 +0100 Subject: [PATCH 06/13] Keep file open and flush changes Suggested by aheadley in IRC --- overviewer_core/observer.py | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/overviewer_core/observer.py b/overviewer_core/observer.py index f6c0bfb..7db5061 100644 --- a/overviewer_core/observer.py +++ b/overviewer_core/observer.py @@ -179,11 +179,13 @@ class JSObserver(Observer): self.last_update_time = -1 self._current_value = -1 self.minrefresh = 1000*minrefresh - self.logfile = os.path.join(outputdir, "progress.js") + self.logfile = open(os.path.join(outputdir, "progress.js"), "w+", 0) def start(self, max_value): - f = open(self.logfile, "w", 0) - f.write('{"message": "Rendering %d tiles", "update": %s}' % (max_value, self.minrefresh)) + self.logfile.seek(0) + self.logfile.write('{"message": "Rendering %d tiles", "update": %s}' % (max_value, self.minrefresh)) + self.logfile.truncate() + self.logfile.flush() self.start_time=time.time() self._set_max_value(max_value) @@ -196,9 +198,10 @@ class JSObserver(Observer): """ self.end_time = time.time() duration = self.end_time - self.start_time - f = open(self.logfile, "w", 0) - f.write('{"message": "Render completed in %dm %ds", "update": "false"}' % (duration//60, duration - duration//60)) - f.close() + self.logfile.seek(0) + self.logfile.write('{"message": "Render completed in %dm %ds", "update": "false"}' % (duration//60, duration - duration//60)) + self.logfile.truncate() + self.logfile.close() def is_finished(self): return self.end_time is not None @@ -220,9 +223,10 @@ class JSObserver(Observer): self._current_value = current_value if self._need_update(): refresh = max(1500*(time.time() - self.last_update_time), self.minrefresh) - f = open(self.logfile, "w", 0) - f.write('{"message": "Rendered %d of %d tiles (%d%%)", "update": %d }' % (self.get_current_value(), self.get_max_value(), self.get_percentage(), refresh)) - f.close() + self.logfile.seek(0) + self.logfile.write('{"message": "Rendered %d of %d tiles (%d%%)", "update": %d }' % (self.get_current_value(), self.get_max_value(), self.get_percentage(), refresh)) + self.logfile.truncate() + self.logfile.flush() self.last_update_time = time.time() self.last_update = current_value return True From 16acdd47d432d95da02f47cbc438436f6a64b13d Mon Sep 17 00:00:00 2001 From: aheadley Date: Sat, 31 Mar 2012 19:25:50 -0400 Subject: [PATCH 07/13] add ServerAnnounce and Multiplexing observers Conflicts: overviewer_core/observer.py --- overviewer_core/observer.py | 54 +++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/overviewer_core/observer.py b/overviewer_core/observer.py index 7db5061..aafbfa0 100644 --- a/overviewer_core/observer.py +++ b/overviewer_core/observer.py @@ -258,3 +258,57 @@ class JSObserver(Observer): else: return cur_val - self.last_update > 100 +class MultiplexingObserver(Observer): + """Combine multiple observers into one. + """ + def __init__(self, *components): + self.components = components + super(MultiplexingObserver, self).__init__() + + def start(self, max_value): + for o in self.components: + o.start(max_value) + super(MultiplexingObserver, self).start(max_value) + + def finish(self): + for o in self.components: + o.finish() + super(MultiplexingObserver, self).finish() + + def update(self, current_value): + for o in self.components: + o.update(current_value) + super(MultiplexingObserver, self).update(max_value) + +class ServerAnnounceObserver(Observer): + """Send the output to a Minecraft server via FIFO or stdin""" + def __init__(self, target='/dev/null', pct_interval=10): + self.pct_interval = pct_interval + self.target_handle = open(target, 'w') + self.last_update = 0 + super(ServerAnnounceObserver, self).__init__() + + def start(self, max_value): + self._send_output('Starting render of %d total tiles' % max_value) + super(ServerAnnounceObserver, self).start(max_value) + + def finish(self): + self._send_output('Render complete!') + super(ServerAnnounceObserver, self).finish() + self.target_handle.close() + + def update(self, current_value): + super(ServerAnnounceObserver, self).update(current_value) + if self._need_update(current_value): + self._send_output('Rendered %d of %d tiles, %d%% complete' % + (self.get_current_value(), self.get_max_value(), + self.get_percentage())) + + def _need_update(self): + return self.get_percentage() - \ + (self.last_update * 100.0 / self.get_max_value()) >= self.pct_interval + + def _send_output(self, output): + self.target_handle.write('say %s\n' % output) + self.target_handle.flush() + From 9e8f933956037e79cc16165f1d7e1a38b1d4277f Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Fri, 25 May 2012 19:05:20 +0100 Subject: [PATCH 08/13] Update JSObserver (reliability, features, config) * Should now hide/show the div reliably * Message can now be customised by supplying a dict in the config file --- overviewer_core/data/js_src/views.js | 20 ++++++++---- overviewer_core/observer.py | 46 +++++++++++++++++++++++----- 2 files changed, 53 insertions(+), 13 deletions(-) diff --git a/overviewer_core/data/js_src/views.js b/overviewer_core/data/js_src/views.js index bbb9afa..2db2a31 100644 --- a/overviewer_core/data/js_src/views.js +++ b/overviewer_core/data/js_src/views.js @@ -142,17 +142,25 @@ overviewer.views.ProgressView = Backbone.View.extend({ this.el.id = 'progressDiv'; this.el.innerHTML = 'Current Render Progress'; overviewer.map.controls[google.maps.ControlPosition.BOTTOM_RIGHT].push(this.el); - this.hidden = true; + this.el.hidden = true; $.ajaxSetup({cache: false}); }, updateProgress: function() { e = this; - $.getJSON('progress.js', null, function(d){ - e.el.hidden = false; - e.el.innerHTML = d['message']; - if (d.update > 0) { - setTimeout("e.updateProgress()", d.update); + $.getJSON('progress.json', null, function(d){ + console.log(d); + if (!(d == null||d=='')) { + e.el.hidden = false; + e.el.innerHTML = d['message']; + if (d.update > 0) { + setTimeout("e.updateProgress()", d.update); + } else { + setTimeout("e.updateProgress()", 60000); + e.el.innerHTML="Hidden - d.update < 0"; + e.el.hidden = true; + } } else { + e.el.innerHTML="Hidden - !!d==false"; e.el.hidden = true; } }); diff --git a/overviewer_core/observer.py b/overviewer_core/observer.py index 7db5061..3b9d5b1 100644 --- a/overviewer_core/observer.py +++ b/overviewer_core/observer.py @@ -18,6 +18,7 @@ import logging import progressbar import sys import os +import json class Observer(object): """Base class that defines the observer interface. @@ -170,21 +171,42 @@ class JSObserver(Observer): """Display progress on index.html using JavaScript """ - def __init__(self, outputdir, minrefresh=5): + def __init__(self, outputdir, minrefresh=5, messages=False): """Initialise observer outputdir must be set to the map output directory path - minrefresh specifies the minimum gap between requests, in seconds + minrefresh specifies the minimum gap between requests, in seconds [optional] + messages is a dictionary which allows the displayed messages to be customised [optional] """ self.last_update = -11 self.last_update_time = -1 self._current_value = -1 self.minrefresh = 1000*minrefresh - self.logfile = open(os.path.join(outputdir, "progress.js"), "w+", 0) + self.logfile = open(os.path.join(outputdir, "progress.json"), "w+", 0) + self.json = dict() + + if (messages == False): + self.messages=dict(totalTiles="Rendering %d tiles", renderCompleted="Render completed in %02d:%02d:%02d", renderProgress="Rendered %d of %d tiles (%d%%)") + elif (isinstance(messages, dict)): + if (totalTiles in messages and renderCompleted in messages and renderProgress in messages): + self.messages = messages + else: + raise Exception("JSObserver: messages parameter must be a dictionary with three entries: totalTiles, renderCompleted and renderProgress") + else: + raise Exception("JSObserver: messages parameter must be a dictionary with three entries: totalTiles, renderCompleted and renderProgress") + + self.json["message"]="" + self.json["update"]=self.minrefresh + self.json["messageTime"]=time.time() + json.dump(self.json, self.logfile) + self.logfile.flush() def start(self, max_value): self.logfile.seek(0) - self.logfile.write('{"message": "Rendering %d tiles", "update": %s}' % (max_value, self.minrefresh)) self.logfile.truncate() + self.json["message"] = self.messages["totalTiles"] % (max_value) + self.json["update"] = self.minrefresh + self.json["messageTime"] = time.time() + json.dump(self.json, self.logfile) self.logfile.flush() self.start_time=time.time() self._set_max_value(max_value) @@ -199,8 +221,15 @@ class JSObserver(Observer): self.end_time = time.time() duration = self.end_time - self.start_time self.logfile.seek(0) - self.logfile.write('{"message": "Render completed in %dm %ds", "update": "false"}' % (duration//60, duration - duration//60)) self.logfile.truncate() + hours = duration // 3600 + duration = duration % 3600 + minutes = duration // 60 + seconds = duration % 60 + self.json["message"] = self.messages["renderCompleted"] % (hours, minutes, seconds) + self.json["update"] = -1 # Initially this was set to False, but that runs into some JS strangeness. -1 is less nice, but works + self.json["messageTime"] = time.time() + json.dump(self.json, self.logfile) self.logfile.close() def is_finished(self): @@ -222,10 +251,13 @@ class JSObserver(Observer): """ self._current_value = current_value if self._need_update(): - refresh = max(1500*(time.time() - self.last_update_time), self.minrefresh) + refresh = max(1500*(time.time() - self.last_update_time), self.minrefresh) // 1 self.logfile.seek(0) - self.logfile.write('{"message": "Rendered %d of %d tiles (%d%%)", "update": %d }' % (self.get_current_value(), self.get_max_value(), self.get_percentage(), refresh)) self.logfile.truncate() + self.json["message"] = self.messages["renderProgress"] % (self.get_current_value(), self.get_max_value(), self.get_percentage()) + self.json["update"] = refresh + self.json["messageTime"] = time.time() + json.dump(self.json, self.logfile) self.logfile.flush() self.last_update_time = time.time() self.last_update = current_value From 0a90f0f896ffef52aec23daf14fb250f3d8cf05a Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Fri, 25 May 2012 19:12:23 +0100 Subject: [PATCH 09/13] Remove errant console.log() --- overviewer_core/data/js_src/views.js | 1 - 1 file changed, 1 deletion(-) diff --git a/overviewer_core/data/js_src/views.js b/overviewer_core/data/js_src/views.js index 2db2a31..1182a57 100644 --- a/overviewer_core/data/js_src/views.js +++ b/overviewer_core/data/js_src/views.js @@ -148,7 +148,6 @@ overviewer.views.ProgressView = Backbone.View.extend({ updateProgress: function() { e = this; $.getJSON('progress.json', null, function(d){ - console.log(d); if (!(d == null||d=='')) { e.el.hidden = false; e.el.innerHTML = d['message']; From c05d628723114119e1909ec2119a6e21e1240075 Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Fri, 25 May 2012 19:15:54 +0100 Subject: [PATCH 10/13] Correct 'if x in messages' to 'if "x" in messages' --- overviewer_core/observer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/overviewer_core/observer.py b/overviewer_core/observer.py index 3b9d5b1..0e1c587 100644 --- a/overviewer_core/observer.py +++ b/overviewer_core/observer.py @@ -187,7 +187,7 @@ class JSObserver(Observer): if (messages == False): self.messages=dict(totalTiles="Rendering %d tiles", renderCompleted="Render completed in %02d:%02d:%02d", renderProgress="Rendered %d of %d tiles (%d%%)") elif (isinstance(messages, dict)): - if (totalTiles in messages and renderCompleted in messages and renderProgress in messages): + if ('totalTiles' in messages and 'renderCompleted' in messages and 'renderProgress' in messages): self.messages = messages else: raise Exception("JSObserver: messages parameter must be a dictionary with three entries: totalTiles, renderCompleted and renderProgress") From 2ef6951e2827ecbe9a0809b99738e7e2007b901a Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Fri, 25 May 2012 20:38:32 +0100 Subject: [PATCH 11/13] Make JSObserver throw a more helpful error if path not valid --- overviewer_core/observer.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/overviewer_core/observer.py b/overviewer_core/observer.py index 0e1c587..b2e4619 100644 --- a/overviewer_core/observer.py +++ b/overviewer_core/observer.py @@ -181,7 +181,6 @@ class JSObserver(Observer): self.last_update_time = -1 self._current_value = -1 self.minrefresh = 1000*minrefresh - self.logfile = open(os.path.join(outputdir, "progress.json"), "w+", 0) self.json = dict() if (messages == False): @@ -193,7 +192,10 @@ class JSObserver(Observer): raise Exception("JSObserver: messages parameter must be a dictionary with three entries: totalTiles, renderCompleted and renderProgress") else: raise Exception("JSObserver: messages parameter must be a dictionary with three entries: totalTiles, renderCompleted and renderProgress") + if not os.path.exists(outputdir): + raise Exception("JSObserver: Output directory specified (%s) doesn't appear to exist. This should be the same as the Overviewer output directory") + self.logfile = open(os.path.join(outputdir, "progress.json"), "w+", 0) self.json["message"]="" self.json["update"]=self.minrefresh self.json["messageTime"]=time.time() From beaa2a9f09db9a99c594bf821ebef557b1db429a Mon Sep 17 00:00:00 2001 From: Thomas Lake Date: Fri, 25 May 2012 21:44:23 +0100 Subject: [PATCH 12/13] JSObserver documentation --- docs/config.rst | 37 ++++++++++++++++++++++++++++++------- 1 file changed, 30 insertions(+), 7 deletions(-) diff --git a/docs/config.rst b/docs/config.rst index c41d995..3e79340 100644 --- a/docs/config.rst +++ b/docs/config.rst @@ -269,16 +269,39 @@ the form ``key = value``. Two items take a different form:, ``worlds`` and This is used by default when the output is a terminal. Displays a text based progress bar and some statistics. - ``JSObserver`` + ``JSObserver(outputdir[, minrefresh][, messages])`` This will display render progress on the output map in the bottom right - corner of the screen. ``JSObserver`` must be invoked with two parameters. + corner of the screen. ``JSObserver``. - The first is output directory. For simplicity, specify this as ``outputdir`` - and place this line after setting ``outputdir = ""``. + * ``outputdir="`` + Progress information won't be written to file or requested by your + web browser more frequently than this interval. + + * ``messages=dict(totalTiles=, renderCompleted=, renderProgress=)`` + Customises messages displayed in browser. All three messages must be + defined as follows: + + * ``totalTiles="Rendering %d tiles"`` + The ``%d`` format string will be replaced with the total number of + tiles to be rendered. + + * ``renderCompleted="Render completed in %02d:%02d:%02d"`` + The three format strings will be replaced with the number of hours. + minutes and seconds taken to complete this render. + + * ``renderProgress="Rendered %d of %d tiles (%d%%)"`` + The three format strings will be replaced with the number of tiles + completed, the total number of tiles and the percentage complete + + Format strings are explained here: http://docs.python.org/library/stdtypes.html#string-formatting + All format strings must be present in your custom messages. + :: from observer import JSObserver From 1980c3aee13eea89886c54debaf8e3e317a1350c Mon Sep 17 00:00:00 2001 From: Andrew Chin Date: Sun, 10 Jun 2012 20:39:42 -0400 Subject: [PATCH 13/13] Fixed type in Multiplexing Observer --- overviewer_core/observer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/overviewer_core/observer.py b/overviewer_core/observer.py index 20fb764..b409fd4 100644 --- a/overviewer_core/observer.py +++ b/overviewer_core/observer.py @@ -312,7 +312,7 @@ class MultiplexingObserver(Observer): def update(self, current_value): for o in self.components: o.update(current_value) - super(MultiplexingObserver, self).update(max_value) + super(MultiplexingObserver, self).update(current_value) class ServerAnnounceObserver(Observer): """Send the output to a Minecraft server via FIFO or stdin"""