~kiddo/specto/pygi

# -*- coding: utf-8 -*-

# Specto , Unobtrusive event notifier

#

#       watch.py

#

# See the AUTHORS file for copyright ownership information

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public

# License as published by the Free Software Foundation; either

# version 2 of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public

# License along with this program; if not, write to the

# Free Software Foundation, Inc., 59 Temple Place - Suite 330,

# Boston, MA 02111-1307, USA.

import os

import sys

import time

import gobject

import thread

from gi.repository import Gtk

from cgi import escape

try:

    import dbus

    DBUS = True

except:

    DBUS = False

#specto imports

import spectlib.config

from spectlib.tools.iniparser import ini_namespace

from ConfigParser import ConfigParser

from datetime import datetime

keyring = True

try:

    from spectlib.tools.keyringmanager import Keyring

except:

    keyring = False

def gettext_noop(s):

    return s

class Watch:

    def __init__(self, specto, id, values, watch_values):

        self.specto = specto

        watch_values.extend([('name', spectlib.config.String(True)),

                            ('refresh', spectlib.config.Integer(True)),

                            ('type', spectlib.config.String(True)),

                            ('changed', spectlib.config.Boolean(False)),

                            ('command', spectlib.config.String(False)),

                            ('active', spectlib.config.Boolean(False)),

                            ('last_changed', spectlib.config.String(False)),

                            ('open_command', spectlib.config.String(False))])

        self.id = id

        self.use_network = False

        self.error = False

        self.actually_changed = False

        self.dbus = False

        self.session_bus = None

        self.timer_id = -1

        self.deleted = False

        self.error_message = ""

        self.watch_values = watch_values

        self.set_values(values)

        self.watch_io = Watch_io(self.specto, self.specto.FILE)

        global _

    def start(self):

        """ Start the watch. """

        try:

            self.active = True

            self.watch_io.write_option(self.name, 'active', self.active)

            self.start_checking()

        except:

            self.error = True

            self.set_error(_("There was an error starting the watch"))

    def stop(self):

        """ Stop the watch. """

        try:

            self.active = False

            self.watch_io.write_option(self.name, 'active', self.active)

            if self.dbus and self.session_bus:

                for signal, call_back in self.signals.items():

                    self.session_bus.remove_signal_receiver(

                        call_back,

                        signal,

                        self.dbus_interface,

                        self.dbus_name,

                        self.dbus_path)

            else:

                GObject.source_remove(self.timer_id)

        except:

            self.error = True

            self.set_error(_("There was an error stopping the watch"))

    def mark_as_read(self):

        """ mark the watch as read """

        try:

            self.changed = False

            self.watch_io.write_option(self.name, 'changed', self.changed)

            if not self.error:

                self.specto.mark_watch_status("read", self.id)

                self.specto.mark_watch_status("idle", self.id)

        except:

            self.set_error(_("There was an error marking the watch as read"))

    def restart(self):

        """ restart the watch """

        if self.active == True:

            self.stop()

        self.start()

    def start_checking(self):

        try:

            self.specto.logger.log(_("Watch started checking."),\

                                                 "debug", self.name)

            self.error = False

            self.actually_changed = False

            if self.dbus and DBUS:

                self.session_bus = dbus.SessionBus()

                self.obj = self.session_bus.get_object(self.dbus_name, self.dbus_path)

                self.iface = dbus.Interface(self.obj, self.dbus_interface)

                for signal, call_back in self.signals.items():

                    self.session_bus.add_signal_receiver(

                        call_back,

                        signal,

                        self.dbus_interface,

                        self.dbus_name,

                        self.dbus_path)

            else:

                if self.use_network:

                    if not self.check_connection():

                        return                

                self.specto.mark_watch_status("checking", self.id) 

                self.lock = thread.allocate_lock()

                self.lock.acquire()

                thread.start_new_thread(self.check, ())

                while self.lock.locked():

                    while Gtk.events_pending():

                        Gtk.main_iteration()

                    time.sleep(0.05)

        except:

            self.set_error(_("There was an error checking the watch"))

    def watch_changed(self):

        try:

            self.specto.logger.log(_("Watch has changed."), "info", self.name)

            self.actually_changed = False

            self.changed = True

            self.last_changed = datetime.today().strftime("%A %d %b %Y %H:%M")

            self.watch_io.write_option(self.name, 'changed', self.changed)

            self.watch_io.write_option(self.name, 'last_changed', \

                                                       self.last_changed)

            self.specto.mark_watch_status("changed", self.id)

            command = self.replace_variables(self.command)

            if command != "": #run watch specific "changed" command

                os.system(command + " &")

        except:

            self.set_error(_("There was an error marking the watch as changed"))

    def timer_update(self):

        """ update the timer """

        try:

            if self.actually_changed == True:

                self.watch_changed()

            elif self.error == True:

                self.specto.mark_watch_status("error", self.id)

            elif self.active == False:

                self.stop()

            else:

                self.specto.mark_watch_status("idle", self.id)

            try:

                self.lock.release()

                self.timer_id = GObject.timeout_add(self.refresh, self.start_checking)

            except:

                self.timer_id = GObject.timeout_add(self.refresh, self.check)

        except:

            self.set_error(_("There was an error checking the watch"))

    def check_connection(self):

        if not self.specto.connection_manager.connected():

            self.specto.logger.log(_("No network connection detected"), "warning", self.name)

            self.specto.connection_manager.add_callback(self.start_checking)

            self.specto.mark_watch_status("no-network", self.id)

            return False

        else:

            self.specto.mark_watch_status("idle", self.id)

            return True

    def get_values(self):

        return self.values

    def set_values(self, values, validate=False):

        error_fields = ""

        for key, type in self.watch_values:

            try:

                value = values[key]

            except KeyError:

                if type.mandatory == False:

                    values[key] = type.getStandardValue()

                    value = values[key]

                    if not validate:

                        setattr(self, key, value)

                else:

                    error_fields += ", " + key

            else:

                value = type.checkRestrictions(values[key])

                if value[0] == True:

                    if type.mandatory == True and value[1] == type.getStandardValue():

                        error_fields += ", " + key

                    else:

                        values[key] = value[1]

                        if not validate:

                            setattr(self, key, value[1])

                else:

                    error_fields += ", " + key

        if values['open_command'] == "":

            try:

                self.open_command = self.standard_open_command

            except:

                self.open_command = ""

        if self.last_changed == "" or self.last_changed == _("No changes yet") or self.last_changed == "No changes yet": #otherwise, it will be saved untranslated in the watch list

            self.last_changed = _("No changes yet")

        if len(error_fields) != 0:

            error_fields = error_fields.lstrip(",")

            raise AttributeError(error_fields)

        else:

            if not validate:

                self.values = values

    def get_balloon_text(self):

        return "No message specified yet!" #no need to translate this, if users get to see this, it's no good

    def get_extra_information(self):

        """Provide information to be shown in the Extra information tab in the notifier window.

        Remember to use the escape method to sanitize special characters before adding formatting."""

        return _("No extra information available.")

    def open_watch(self, *args):

        open_command = self.replace_variables(self.open_command) 

        if open_command != "":

            os.system(open_command + " &")

            self.mark_as_read()

            return True

        else:

            return False

    def replace_variables(self, command):

        _command = command

        available_variables = {"%extra_information": "'" + self.get_extra_information().replace("'", "") + "'",

                               "%information": "'" + self.get_balloon_text().replace("'", "") + "'",

                               "%name": "'" +  self.name.replace("'", "\'") + "'",

                               "%last_changed": "'" + self.last_changed.replace("'", "") + "'"}

        for variable in available_variables:

            _command = _command.replace(variable, available_variables[variable])

        return _command

    def escape(self, text):

        """Sanitize the input to remove special characters, PyGTK doesn't like them.

        Use this in the get_extra_information method of watches."""

        text = escape(text)  # Remove the biggest part using the CGI library's escape function

        text = str(text).replace('<', "&lt;").replace('>', "&gt;") # Escape the < and > characters

        return text

    def remove_cache_files(self):

        return ""

    def set_error(self, message=""):

        self.error = True

        if message != "":

            self.error_message = str(message).replace('\n',' ')

            self.specto.logger.log(('%s') % self.error_message, "error", self.name)

        else:

            self.error_message = _("Unexpected error:") + " " + str(sys.exc_info()[1])

            self.specto.logger.log(self.error_message, "error", self.name)

class Watch_collection:

    def __init__(self, specto):

        self.watch_db = []

        self.plugin_menu = {}

        self.id = 0

        self.plugin_dict = {}

        self.disabl_plugin_dict = {}

        self.specto = specto

        self.load_plugins()

    def load_plugins(self):

        dir = self.specto.SRC_PATH + "/plugins/"

        sys.path.append(dir)

        for f in os.listdir(dir):

            if f[-3:] == ".py" and f != "__init__.py":

                if not os.path.exists('data'):

                    dir = "spectlib.plugins."

                else:

                    dir = "spectlib/plugins/"

                _file = f[:-3]

                try:

                    mod = __import__(_file, globals(), locals(), [''])

                    obj = sys.modules[_file]

                    self.plugin_dict[obj.type] = mod

                    #create the plugin dict for add menu

                    menu1 = obj.category

                    menu2 = [obj.type_desc, obj.icon, obj.type]

                    if not menu1 in self.plugin_menu:

                        self.plugin_menu.update({menu1: []})

                    self.plugin_menu[menu1].append(menu2)

                except:

                    self.specto.logger.log(_('There was an error opening the file %s') % _file, "critical", "specto")

    def create(self, values):

        """ read the content from the dictionary and create the watch """

        _id = []

        for i in values:

            type = values[i]['type']

            #get the right object and create the watch object

            mod = ""

            try:

                mod = self.plugin_dict[type]

            except:

                self.specto.logger.log(_('Please enable plugin "%s" if you want to use the watch "%s".') % (type, values[i]["name"]), "critical", "specto")

            if mod:

                obj = getattr(mod, type)

                try:

                    watch_ = obj(self.specto, self.id, values[i])

                except AttributeError, error_fields:

                    if len(values) > 1:

                        pass

                    else:

                        raise AttributeError(error_fields)

                else:

                    self.watch_db.append(watch_)

                    _id.append(self.id)

                    self.id += 1

        return _id

    def remove(self, id):

        """ remove the watch from the collection """

        self.watch_db[id].stop()

        self.watch_db[id].changed = False

        self.watch_db[id].deleted = True

        try:

            self.watch_db[id].remove_cache_files()

        except:

            pass

        self.specto.logger.remove_watch_log(self.watch_db[id].name)

    def get(self, id):

        """ get a watch object """

        return self.watch_db[id]

    def mark_all_watches_as_read(self):

        """ mark all watches as not changed """

        for watch in self.watch_db:

            watch.mark_as_read()

    def start_all_watches(self):

        """ start all watches in the collection """

        for watch in self.watch_db:

            watch.start()

    def stop_all_watches(self):

        """ stop all watches in the collection """

        for watch in self.watch_db:

            watch.stop()

    def restart_all_watches(self):

        """ restart all watches in the collection """

        for watch in self.watch_db:

            if watch.active == True:

                watch.restart()

    def length(self):

        """ return the length from the collection """

        return len(self.watch_db)

    def count_changed_watches(self):

        """ Count the number of changed watches for the tooltip. """

        count_changed = {}

        for watch in self.watch_db:

            try:

                count_changed[watch.type_desc]

            except KeyError:

                count_changed[watch.type_desc] = 0

            if watch.changed == True:

                changes = count_changed[watch.type_desc]

                count_changed[watch.type_desc] = changes + 1

        return count_changed

    def find_watch(self, name):

        """

        Returns the key of a watch or None if it doesn't exists.

        """

        k = -1

        for watch in self.watch_db:

            if watch.name == name:

                k = watch.id

                break

        return k

    def set_interval(self, refresh, refresh_unit):

        """

        Set the interval between the checks.

        refresh = number

        refresh_unit = days, hours, minutes,... in values of 0, 1, 2, 3.

        """

        new_refresh = 0

        if refresh_unit == 0:  # Seconds

            new_refresh = refresh * 1000

        elif refresh_unit == 1:  # Minutes

            new_refresh = refresh * 60 * 1000

        elif refresh_unit == 2:  # Hours

            new_refresh = (refresh * 60) * 60 * 1000

        elif refresh_unit == 3:  # Days

            new_refresh = ((refresh * 60) * 60) * 24 *1000

        return new_refresh

    def convert_passwords(self, use_keyring):

        self.specto.use_keyring = use_keyring

        for watch in self.watch_db:

            if 'password' in watch.values:

                if use_keyring == False:

                    self.specto.watch_io.remove_keyring(watch.name)

                self.specto.watch_io.write_option(watch.name, 'password', watch.password)

    def get_interval(self, value):

        """ Get the interval between 2 checks. """

        if ((value / 60) / 60) / 24 / 1000 > 0:

            refresh_value = ((value / 60) / 60) / 24 / 1000

            type = 3

        elif (value / 60) / 60 / 1000 > 0:

            refresh_value = (value / 60) / 60 / 1000

            type = 2

        elif value / 60 / 1000 > 0:

            refresh_value = value / 60 / 1000

            type = 1

        else:

            refresh_value = value / 1000

            type = 0

        return refresh_value, type

    def __getitem__(self, i):

        return self.watch_db[i]

class Watch_io:

    """

    A class for managing watches.

    """

    def __init__(self, specto, file_name):

        # Read the watch from file using the iniparser module

        self.specto = specto

        self.file_name = file_name

        self.valid = True

        if not os.path.exists(self.file_name):

            try:

                f = open(self.file_name, "w")

            except:

                self.valid = False

                self.specto.logger.log(_("There was an error writing to the file %s") % self.file_name, "critical", "specto")

            finally:

                f.close()

        os.chmod(self.file_name, 0600)  # This is important for security purposes, we make the file read-write to the owner only, otherwise everyone can read passwords.

        try:

            self.cfg = ini_namespace(file(self.file_name))

        except:

            self.valid = False

            self.specto.logger.log(_("There was an error initializing config file %s") % self.file_name, "critical", "specto")

    def read_all_watches(self, startup=False):

        """

        Read the watch options from the config file

        and return a dictionary containing the info needed to start the watches.

        """

        watch_value_db = {}

        if startup == False:

            try:

                self.cfg = ini_namespace(file(self.file_name))

            except:

                self.specto.logger.log(_("There was an error initializing config file %s") % self.file_name, "critical", "specto")

                return False

        names = self.cfg._sections.keys()

        i = 0

        for name_ in names:

            watch_value_db[i] = self.read_watch(name_, startup)

            i += 1

        return watch_value_db

    def read_watch(self, name, startup=False):

        """

        Read the watch options from one watch.

        """

        watch_options = {}

        if startup == False:

            try:

                self.cfg = ini_namespace(file(self.file_name))

            except:

                self.specto.logger.log(_("There was an error initializing config file %s") % self.file_name, "critical", "specto")

                return False

        name = self.hide_brackets(name)

        options = self.cfg._sections[name]._options.keys()

        for option_ in options:

            if option_ == "password" and not self.check_old_version(self.cfg[name]['type']): #don't use decoding for old watches.list

                option = self.read_option(name, option_, startup)

                option = self.decode_password(name, option)

            else:

                option = self.read_option(name, option_, startup)

            watch_options_ = {option_: option}

            watch_options.update(watch_options_)

        name = self.show_brackets(name)

        watch_options.update({'name': name})

        return watch_options

    def read_option(self, name, option, startup=False):

        """ Read one option from a watch """

        if startup == False:

            try:

                self.cfg = ini_namespace(file(self.file_name))

            except:

                self.specto.logger.log(_("There was an error initializing config file %s") % self.file_name, "critical", "specto")

                return False

        try:

            return self.cfg[name][option]

        except:

            return 0

    def write_watch(self, values):