OpenSlides/extras/openslides_gui/gui.py

from __future__ import unicode_literals

import Queue
import datetime
import errno
import gettext
import itertools
import json
import locale
import os
import subprocess
import sys
import threading

import wx

import openslides

from openslides.utils.main import (
    detect_openslides_type,
    filesystem2unicode,
    unicode2filesystem,
    get_default_user_data_path,
    get_port,
    PortableDirNotWritable,
)


# NOTE: djangos translation module can't be used here since it requires
#       a defined settings module
_translations = gettext.NullTranslations()
_ = lambda text: _translations.ugettext(text)
ungettext = lambda msg1, msg2, n: _translations.ungettext(msg1, msg2, n)


def get_data_path(*args):
    path = filesystem2unicode(__file__)
    return os.path.join(os.path.dirname(path), "data", *args)


class RunCmdEvent(wx.PyCommandEvent):
    def __init__(self, evt_type, evt_id):
        super(RunCmdEvent, self).__init__(evt_type, evt_id)

        self.running = False
        self.exitcode = None

EVT_RUN_CMD_ID = wx.NewEventType()
EVT_RUN_CMD = wx.PyEventBinder(EVT_RUN_CMD_ID, 1)


class RunCommandControl(wx.Panel):
    UPDATE_INTERVAL = 500

    def __init__(self, parent):
        super(RunCommandControl, self).__init__(parent)

        self.child_process = None
        self.output_queue = Queue.Queue()
        self.output_read_thread = None
        self.canceled = False
        self.output_mutex = threading.RLock()

        vbox = wx.BoxSizer(wx.VERTICAL)

        self.te_output = wx.TextCtrl(
            self, style=wx.TE_MULTILINE | wx.TE_READONLY | wx.HSCROLL)
        vbox.Add(self.te_output, 1, wx.EXPAND)

        self.update_timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.on_update_timer, self.update_timer)

        self.SetSizerAndFit(vbox)

    def _read_output(self):
        while True:
            # NOTE: don't use iterator interface since it uses an
            # internal buffer and we don't see output in a timely fashion
            line = self.child_process.stdout.readline()
            if not line:
                break
            self.output_queue.put(line)

    def is_alive(self):
        if self.child_process is None:
            return False
        return self.child_process.poll() is None

    def run_command(self, *args):
        if self.is_alive():
            raise ValueError("already running a command")

        cmd = [sys.executable, "-u", "-m", "openslides"]
        cmd.extend(args)

        # XXX: subprocess on windows only handles byte strings
        #      with python3 this will hopefully no longer be the case
        cmd = [unicode2filesystem(x) for x in cmd]

        creationflags = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
        self.child_process = subprocess.Popen(
            cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT, creationflags=creationflags)
        self.child_process.stdin.close()
        self.output_read_thread = threading.Thread(target=self._read_output)
        self.output_read_thread.start()

        self.update_timer.Start(self.UPDATE_INTERVAL)

        evt = RunCmdEvent(EVT_RUN_CMD_ID, self.GetId())
        evt.running = True
        self.GetEventHandler().ProcessEvent(evt)

    def cancel_command(self):
        if not self.is_alive():
            return

        # TODO: try sigint first, then get more aggressive if user insists
        self.child_process.kill()
        self.canceled = True

    def on_update_timer(self, evt):
        is_alive = self.is_alive()
        if not is_alive:
            # join thread to make sure everything was read
            self.output_read_thread.join()
            self.output_read_thread = None

        for line_no in itertools.count():
            try:
                data = self.output_queue.get(block=False)
            except Queue.Empty:
                break
            else:
                # XXX: check whether django uses utf-8 or locale for
                #      it's cli output
                text = data.decode("utf-8", errors="replace")
                with self.output_mutex:
                    self.te_output.AppendText(text)

                # avoid waiting too long here if child is still alive
                if is_alive and line_no > 10:
                    break

        if not is_alive:
            exitcode = self.child_process.returncode
            self.update_timer.Stop()
            self.child_process = None

            evt = RunCmdEvent(EVT_RUN_CMD_ID, self.GetId())
            evt.running = False
            evt.exitcode = exitcode
            self.GetEventHandler().ProcessEvent(evt)

    def append_message(self, text, newline="\n"):
        with self.output_mutex:
            self.te_output.AppendText(text + newline)


class SettingsDialog(wx.Dialog):
    def __init__(self, parent):
        super(SettingsDialog, self).__init__(parent, wx.ID_ANY, _("Settings"))

        grid = wx.GridBagSizer(5, 5)
        row = 0

        lb_host = wx.StaticText(self, label=_("&Host:"))
        grid.Add(lb_host, pos=(row, 0))
        self.tc_host = wx.TextCtrl(self)
        grid.Add(self.tc_host, pos=(row, 1), flag=wx.EXPAND)

        row += 1

        lb_port = wx.StaticText(self, label=_("&Port:"))
        grid.Add(lb_port, pos=(row, 0))
        self.tc_port = wx.TextCtrl(self)
        grid.Add(self.tc_port, pos=(row, 1), flag=wx.EXPAND)

        row += 1

        sizer = self.CreateButtonSizer(wx.OK | wx.CANCEL)
        if not sizer is None:
            grid.Add((0, 0), pos=(row, 0), span=(1, 2))
            row += 1
            grid.Add(sizer, pos=(row, 0), span=(1, 2))

        box = wx.BoxSizer(wx.VERTICAL)
        box.Add(
            grid, flag=wx.EXPAND | wx.ALL | wx.ALIGN_CENTER_VERTICAL,
            border=5, proportion=1)

        self.SetSizerAndFit(box)

    @property
    def host(self):
        return self.tc_host.GetValue()

    @host.setter
    def host(self, host):
        self.tc_host.SetValue(host)

    @property
    def port(self):
        return self.tc_port.GetValue()

    @port.setter
    def port(self, port):
        self.tc_port.SetValue(port)


class BackupSettingsDialog(wx.Dialog):
    # NOTE: keep order in sync with _update_interval_choices()
    _INTERVAL_UNITS = ["second", "minute", "hour"]

    def __init__(self, parent):
        super(BackupSettingsDialog, self).__init__(
            parent, wx.ID_ANY, _("Database backup"))

        self._interval_units = {}

        grid = wx.GridBagSizer(5, 5)
        row = 0

        self.cb_backup = wx.CheckBox(
            self, label=_("&Regularly backup database"))
        self.cb_backup.SetValue(True)
        self.cb_backup.Bind(wx.EVT_CHECKBOX, self.on_backup_checked)
        grid.Add(self.cb_backup, pos=(row, 0), span=(1, 3))
        row += 1

        lb_dest = wx.StaticText(self, label=_("&Destination:"))
        grid.Add(lb_dest, pos=(row, 0))
        style = wx.FLP_SAVE | wx.FLP_USE_TEXTCTRL
        self.fp_dest = wx.FilePickerCtrl(self, style=style)
        grid.Add(self.fp_dest, pos=(row, 1), span=(1, 2), flag=wx.EXPAND)
        row += 1

        lb_interval = wx.StaticText(self, label=_("&Every"))
        grid.Add(lb_interval, pos=(row, 0))
        self.sb_interval = wx.SpinCtrl(self, min=1, initial=1)
        self.sb_interval.Bind(wx.EVT_SPINCTRL, self.on_interval_changed)
        grid.Add(self.sb_interval, pos=(row, 1))
        self.ch_interval_unit = wx.Choice(self)
        grid.Add(self.ch_interval_unit, pos=(row, 2))
        row += 1

        grid.AddGrowableCol(1)

        sizer = self.CreateButtonSizer(wx.OK | wx.CANCEL)
        if not sizer is None:
            grid.Add((0, 0), pos=(row, 0), span=(1, 3))
            row += 1
            grid.Add(sizer, pos=(row, 0), span=(1, 3))

        box = wx.BoxSizer(wx.VERTICAL)
        box.Add(
            grid, flag=wx.EXPAND | wx.ALL | wx.ALIGN_CENTER_VERTICAL,
            border=5, proportion=1)

        self.SetSizerAndFit(box)
        self._update_interval_choices()
        self._update_backup_enabled()

    @property
    def backupdb_enabled(self):
        return self.cb_backup.GetValue()

    @backupdb_enabled.setter
    def backupdb_enabled(self, enabled):
        self.cb_backup.SetValue(enabled)
        self._update_backup_enabled()

    @property
    def backupdb_destination(self):
        return self.fp_dest.GetPath()

    @backupdb_destination.setter
    def backupdb_destination(self, path):
        self.fp_dest.SetPath(path)

    @property
    def interval(self):
        return self.sb_interval.GetValue()

    @interval.setter
    def interval(self, value):
        self.sb_interval.SetValue(value)
        self._update_interval_choices()

    @property
    def interval_unit(self):
        return self._INTERVAL_UNITS[self.ch_interval_unit.GetSelection()]

    @interval_unit.setter
    def interval_unit(self, unit):
        try:
            idx = self._INTERVAL_UNITS.index(unit)
        except IndexError:
            raise ValueError("Unknown unit {0}".format(unit))

        self.ch_interval_unit.SetSelection(idx)

    def _update_interval_choices(self):
        count = self.sb_interval.GetValue()
        choices = [
            ungettext("second", "seconds", count),
            ungettext("minute", "minutes", count),
            ungettext("hour", "hours", count),
        ]

        current = self.ch_interval_unit.GetSelection()
        if current == wx.NOT_FOUND:
            current = 2  # default to hour

        self.ch_interval_unit.Clear()
        self.ch_interval_unit.AppendItems(choices)
        self.ch_interval_unit.SetSelection(current)

    def _update_backup_enabled(self):
        checked = self.cb_backup.IsChecked()
        self.fp_dest.Enable(checked)
        self.sb_interval.Enable(checked)
        self.ch_interval_unit.Enable(checked)

    def on_backup_checked(self, evt):
        self._update_backup_enabled()

    def on_interval_changed(self, evt):
        self._update_interval_choices()

    # TODO: validate settings on close (e.g. non-empty path if backup is
    #       enabled)


class MainWindow(wx.Frame):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent, title="OpenSlides")
        icons = wx.IconBundleFromFile(
            get_data_path("openslides.ico"),
            wx.BITMAP_TYPE_ICO)
        self.SetIcons(icons)

        self.server_running = False

        self.gui_settings_path = None
        self.gui_initialized = False

        self.backupdb_enabled = False
        self.backupdb_destination = ""
        self.backupdb_interval = 15
        self.backupdb_interval_unit = "minute"
        self.last_backup = None

        self.backup_timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.on_backup_timer, self.backup_timer)

        spacing = 5

        panel = wx.Panel(self)
        grid = wx.GridBagSizer(spacing, spacing)

        # logo & about button
        logo_box = wx.BoxSizer(wx.HORIZONTAL)
        grid.Add(logo_box, pos=(0, 0), flag=wx.EXPAND)
        row = 0

        fp = get_data_path("openslides-logo_wide.png")
        with open(fp, "rb") as f:
            logo_wide_bmp = wx.ImageFromStream(f).ConvertToBitmap()

        logo_wide = wx.StaticBitmap(panel, wx.ID_ANY, logo_wide_bmp)
        logo_box.AddSpacer(2 * spacing)
        logo_box.Add(logo_wide)
        logo_box.AddStretchSpacer()

        version_str = _("Version {0}").format(openslides.get_version())
        lb_version = wx.StaticText(panel, label=version_str)
        font = lb_version.GetFont()
        font.SetPointSize(8)
        lb_version.SetFont(font)
        logo_box.Add(lb_version, flag=wx.ALIGN_CENTER_VERTICAL)

        self.bt_about = wx.Button(panel, label=_("&About..."))
        self.bt_about.Bind(wx.EVT_BUTTON, self.on_about_clicked)
        grid.Add(self.bt_about, pos=(row, 1), flag=wx.ALIGN_CENTER_VERTICAL)
        row += 1

        grid.Add((0, spacing), pos=(row, 0), span=(1, 2))
        row += 1

        # server settings
        server_settings = wx.StaticBox(panel, wx.ID_ANY, _("Server Settings"))
        server_box = wx.StaticBoxSizer(server_settings, wx.VERTICAL)
        grid.Add(server_box, pos=(row, 0), flag=wx.EXPAND)

        self._host = None
        self._port = None
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        server_box.Add(hbox, flag=wx.EXPAND)
        self.lb_host = wx.StaticText(panel)
        hbox.Add(self.lb_host, flag=wx.ALIGN_CENTER_VERTICAL)
        hbox.AddStretchSpacer()
        self.lb_port = wx.StaticText(panel)
        hbox.Add(self.lb_port, flag=wx.ALIGN_CENTER_VERTICAL)
        hbox.AddStretchSpacer()
        self.bt_settings = wx.Button(panel, label=_("S&ettings..."))
        self.bt_settings.Bind(wx.EVT_BUTTON, self.on_settings_clicked)
        hbox.Add(self.bt_settings)

        server_box.AddSpacer(spacing)
        self.cb_start_browser = wx.CheckBox(
            panel, label=_("Automatically open &browser"))
        self.cb_start_browser.SetValue(True)
        server_box.Add(self.cb_start_browser)
        server_box.AddStretchSpacer()

        server_box.AddSpacer(spacing)
        self.bt_server = wx.Button(panel, label=_("&Start server"))
        self.bt_server.Bind(wx.EVT_BUTTON, self.on_start_server_clicked)
        server_box.Add(self.bt_server, flag=wx.EXPAND)

        self.host = "0.0.0.0"
        self.port = unicode(get_port(self.host, 80))

        # "action" buttons
        action_vbox = wx.BoxSizer(wx.VERTICAL)
        action_vbox.AddSpacer(3 * spacing)
        grid.Add(action_vbox, pos=(row, 1))
        self.bt_backup = wx.Button(panel, label=_("&Backup database..."))
        self.bt_backup.Bind(wx.EVT_BUTTON, self.on_backup_clicked)
        action_vbox.Add(self.bt_backup)
        action_vbox.AddSpacer(spacing)
        self.bt_sync_db = wx.Button(panel, label=_("S&ync database"))
        self.bt_sync_db.Bind(wx.EVT_BUTTON, self.on_syncdb_clicked)
        action_vbox.Add(self.bt_sync_db)
        action_vbox.AddSpacer(spacing)
        self.bt_reset_admin = wx.Button(panel, label=_("&Reset admin"))
        self.bt_reset_admin.Bind(wx.EVT_BUTTON, self.on_reset_admin_clicked)
        action_vbox.Add(self.bt_reset_admin)
        row += 1

        # command output
        self.cmd_run_ctrl = RunCommandControl(panel)
        self.cmd_run_ctrl.Bind(EVT_RUN_CMD, self.on_run_cmd_changed)
        grid.Add(
            self.cmd_run_ctrl,
            pos=(row, 0), span=(1, 2),
            flag=wx.EXPAND)

        grid.AddGrowableCol(0)
        grid.AddGrowableRow(3)

        box = wx.BoxSizer(wx.VERTICAL)
        box.Add(
            grid, flag=wx.EXPAND | wx.ALL | wx.ALIGN_CENTER_VERTICAL,
            border=spacing, proportion=1)
        panel.SetSizerAndFit(box)
        self.Fit()
        self.SetMinSize(self.ClientToWindowSize(box.GetMinSize()))
        self.SetInitialSize(wx.Size(500, 400))

        self.Bind(wx.EVT_CLOSE, self.on_close)

    def initialize_gui(self):
        if self.gui_initialized:
            return True

        # Set path for gui settings to default user data according to the
        # OpenSlides type. This does not depend on any argument the user might
        # type in.
        openslides_type = detect_openslides_type()
        try:
            default_user_data_path = get_default_user_data_path(openslides_type)
        except PortableDirNotWritable:
            wx.MessageBox(
                _("The portable directory is not writable. Please copy the "
                "openslides portable to a writeable location and start it "
                "again from there"),
                _("Error: Portable directory not writable"),
                wx.OK | wx.ICON_ERROR)
            return False

        self.gui_settings_path = os.path.join(
            default_user_data_path, 'openslides', 'gui_settings.json')
        self.load_gui_settings()
        self.apply_backup_settings()

        self.gui_initialized = True
        return True

    @property
    def backup_interval_seconds(self):
        if self.backupdb_interval_unit == "second":
            factor = 1
        elif self.backupdb_interval_unit == "minute":
            factor = 60
        elif self.backupdb_interval_unit == "hour":
            factor = 3600

        return self.backupdb_interval * factor

    @property
    def host(self):
        return self._host

    @host.setter
    def host(self, host):
        self._host = host
        self.lb_host.SetLabel(_("Host: {0}").format(host))

    @property
    def port(self):
        return self._port

    @port.setter
    def port(self, port):
        self._port = port
        self.lb_port.SetLabel(_("Port: {0}").format(port))

    def load_gui_settings(self):
        if self.gui_settings_path is None:
            return

        try:
            f = open(self.gui_settings_path, "rb")
        except IOError as e:
            if e.errno == errno.ENOENT:
                return
            raise

        with f:
            settings = json.load(f)

        def setattr_unless_none(attr, value):
            if not value is None:
                setattr(self, attr, value)

        backup_settings = settings.get("database_backup", {})
        setattr_unless_none("backupdb_enabled", backup_settings.get("enabled"))
        setattr_unless_none(
            "backupdb_destination", backup_settings.get("destination"))
        setattr_unless_none(
            "backupdb_interval", backup_settings.get("interval"))
        setattr_unless_none(
            "backupdb_interval_unit", backup_settings.get("interval_unit"))
        last_backup = backup_settings.get("last_backup")
        if not last_backup is None:
            self.last_backup = datetime.datetime.strptime(
                last_backup, "%Y-%m-%d %H:%M:%S")
        server_settings = settings.get("server_settings", {})
        setattr_unless_none("host", server_settings.get("host"))
        setattr_unless_none("port", server_settings.get("port"))

    def save_gui_settings(self):
        if self.last_backup is None:
            last_backup = None
        else:
            last_backup = self.last_backup.strftime("%Y-%m-%d %H:%M:%S")
        settings = {
            "database_backup": {
                "enabled": self.backupdb_enabled,
                "destination": self.backupdb_destination,
                "internal": self.backupdb_interval,
                "interval_unit": self.backupdb_interval_unit,
                "last_backup": last_backup
            },
            "server_settings": {
                "host": self.host,
                "port": self.port,
            },
        }

        dp = os.path.dirname(self.gui_settings_path)
        if not os.path.exists(dp):
            os.makedirs(dp)
        with open(self.gui_settings_path, "wb") as f:
            json.dump(settings, f, ensure_ascii=False, indent=4)

    def apply_backup_settings(self):
        if self.backupdb_enabled and self.server_running:
            now = datetime.datetime.utcnow()
            delta = datetime.timedelta(seconds=self.backup_interval_seconds)
            ref = self.last_backup
            if ref is None:
                ref = now
            ref += delta

            d = ref - now
            seconds = d.days * 86400 + d.seconds
            if seconds < 1:
                seconds = 30  # avoid backup immediatly after start
            self.backup_timer.Start(seconds * 1000, True)
        else:
            self.backup_timer.Stop()

    def do_backup(self):
        cmd = [
            sys.executable, "-u", "-m", "openslides", "backupdb",
            self.backupdb_destination,
        ]
        p = subprocess.Popen(
            cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT)
        p.stdin.close()
        output = p.stdout.read().strip()
        exitcode = p.wait()
        if output:
            self.cmd_run_ctrl.append_message(output)

        time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        if exitcode == 0:
            self.cmd_run_ctrl.append_message(
                _("{0}: Database backup successful.").format(time))
        else:
            self.cmd_run_ctrl.append_message(
                _("{0}: Database backup failed!").format(time))

        self.last_backup = datetime.datetime.utcnow()

    def on_syncdb_clicked(self, evt):
        self.cmd_run_ctrl.append_message(_("Syncing database..."))
        self.cmd_run_ctrl.run_command("syncdb")

    def on_reset_admin_clicked(self, evt):
        self.cmd_run_ctrl.append_message(_("Resetting admin user..."))
        self.cmd_run_ctrl.run_command("createsuperuser")

    def on_about_clicked(self, evt):
        info = wx.AboutDialogInfo()
        info.SetName("OpenSlides")
        info.SetVersion(openslides.get_version())
        info.SetDescription(_(
            "OpenSlides is a free web based presentation and "
            "assembly system.\n"
            "OpenSlides is free software; licensed under the MIT license."
        ).replace(u" ", u"\u00a0"))
        info.SetCopyright(_(u"\u00a9 2011-2015 by OpenSlides team"))
        info.SetWebSite(("http://www.openslides.org/", "www.openslides.org"))

        # XXX: at least on wxgtk this has no effect
        info.SetIcon(self.GetIcon())
        wx.AboutBox(info)

    def on_start_server_clicked(self, evt):
        if self.server_running:
            self.cmd_run_ctrl.cancel_command()
            return

        if self._host == "0.0.0.0":
            args = ["--port", self._port]
        else:
            args = ["--address", self._host, "--port", self._port]

        if not self.cb_start_browser.GetValue():
            args.append("--no-browser")

        self.server_running = True
        self.cmd_run_ctrl.run_command("start", *args)

        # initiate backup_timer if backup is enabled
        self.apply_backup_settings()

        self.bt_server.SetLabel(_("&Stop server"))

    def on_settings_clicked(self, evt):
        dlg = SettingsDialog(self)
        dlg.host = self._host
        dlg.port = self._port

        if dlg.ShowModal() == wx.ID_OK:
            self.host = dlg.host
            self.port = dlg.port

    def on_backup_clicked(self, evt):
        dlg = BackupSettingsDialog(self)
        dlg.backupdb_enabled = self.backupdb_enabled
        dlg.backupdb_destination = self.backupdb_destination
        dlg.interval = self.backupdb_interval
        dlg.interval_unit = self.backupdb_interval_unit
        if dlg.ShowModal() == wx.ID_OK:
            self.backupdb_enabled = dlg.backupdb_enabled
            self.backupdb_destination = dlg.backupdb_destination
            self.backupdb_interval = dlg.interval
            self.backupdb_interval_unit = dlg.interval_unit
            self.apply_backup_settings()

    def on_run_cmd_changed(self, evt):
        show_completion_msg = not evt.running
        if self.server_running and not evt.running:
            self.bt_server.SetLabel(_("&Start server"))
            self.server_running = False

            self.backup_timer.Stop()
            if self.backupdb_enabled:
                self.do_backup()

            # no operation completed msg when stopping server
            show_completion_msg = False

        self.bt_settings.Enable(not evt.running)
        self.bt_backup.Enable(not evt.running)
        self.bt_sync_db.Enable(not evt.running)
        self.bt_reset_admin.Enable(not evt.running)
        self.bt_server.Enable(self.server_running or not evt.running)

        if show_completion_msg:
            if evt.exitcode == 0:
                text = _("Operation successfully completed.")
            else:
                text = _("Operation failed (exit code = {0})").format(
                    evt.exitcode)
            self.cmd_run_ctrl.append_message(text)

    def on_backup_timer(self, evt):
        if not self.backupdb_enabled:
            return

        self.do_backup()
        self.backup_timer.Start(1000 * self.backup_interval_seconds, True)

    def on_close(self, ev):
        self.cmd_run_ctrl.cancel_command()
        self.save_gui_settings()
        self.Destroy()

class OpenslidesApp(wx.App):
    def __init__(self):
        super(OpenslidesApp, self).__init__(False)

    def OnInit(self):
        window = MainWindow()
        self.SetTopWindow(window)

        if not window.initialize_gui():
            self.Exit()
            return False

        window.Show()
        return True

def main():
    locale.setlocale(locale.LC_ALL, "")
    lang = locale.getdefaultlocale()[0]
    if lang:
        global _translations
        localedir = filesystem2unicode(openslides.__file__)
        localedir = os.path.dirname(localedir)
        localedir = os.path.join(localedir, "locale")
        _translations = gettext.translation(
            "django", localedir, [lang], fallback=True)

    app = OpenslidesApp()
    app.MainLoop()

if __name__ == "__main__":
    main()