indicator-fileshare

#!/usr/bin/env python3

__author__ = 'aikikode'

import errno
import getpass
import logging.handlers
import os
import shutil
import stat
import subprocess
import sys
import tempfile
import threading
import webbrowser
from configparser import ConfigParser

import gi

gi.require_version('AppIndicator3', '0.1')
from gi.repository import (
    AppIndicator3 as appindicator, GObject, GdkPixbuf, Gtk
)

APP_DIR = '/usr/local/share/indicator-fileshare'
if APP_DIR not in sys.path:
    sys.path.append(APP_DIR)

from upload_services import Imgur, Droplr
from grabbers import FileGrabber, ScreenGrabber

# Choose Imgur because it allows anonymous uploads
DEFAULT_SERVICE_NAME = Imgur.__name__

GObject.threads_init()

VERSION = '0.6.1'

CONFIG_DIR = os.path.join(os.path.expanduser('~'), '.fileshare')
CONFIG_FILE = os.path.join(CONFIG_DIR, 'settings.cfg')

APP_ICON = os.path.join(APP_DIR, 'media', 'app_icon.png')
APP_ICON_PANEL = os.path.join(APP_DIR, 'media', 'app_icon_panel.png')

if not os.path.isdir(CONFIG_DIR):
    os.mkdir(CONFIG_DIR)


class SingleInstance:
    """ Ensure that single instance of the applet is run for each user """

    # Initialize, specifying a path to store pids
    def __init__(self, pid_path):
        self.pid_path = pid_path
        # See if pidFile exists
        if os.path.exists(pid_path):
            log.debug('SingleInstance: pid file {} exists'.format(pid_path))
            # Make sure it is not a 'stale' pidFile
            pid = open(pid_path, 'r').read().strip()
            # Check list of running pids, if not running it is stale so
            # overwrite
            pid_running = subprocess.getoutput(
                'ls -1 /proc | grep ^{}$'.format(pid))
            log.debug('SingleInstance: pid running {}'.format(pid_running))
            self.lasterror = True if pid_running else False
        else:
            self.lasterror = False

        if not self.lasterror:
            log.debug('SingleInstance: writing new pid {}'.format(os.getpid()))
            # Create a temp file, copy it to pid_path and remove temporary file
            (fp, temp_path) = tempfile.mkstemp()
            try:
                os.fdopen(fp, 'w+').write(str(os.getpid()))
                shutil.copy(temp_path, pid_path)
                os.unlink(temp_path)
            except Exception as ex:
                log.error(
                    "SingleInstance: exception while renaming '{}' to '{}':\n"
                    " {}".format(temp_path, pid_path, str(ex))
                )

    def is_already_running(self):
        return self.lasterror

    def __del__(self):
        if not self.lasterror:
            log.debug('SingleInstance: deleting {}'.format(self.pid_path))
            os.unlink(self.pid_path)


class IndicatorFileshare(threading.Thread):
    def __init__(self):
        log.debug('Indicator: creating')
        threading.Thread.__init__(self)
        # TODO: add os.path constant/config
        self._keymap = '<Super>P'
        self.read_settings()
        self.check_autostart()
        self.ind = appindicator.Indicator.new(
            'fileshare-services-client',
            'indicator-fileshare',
            appindicator.IndicatorCategory.APPLICATION_STATUS
        )
        self.ind.set_status(appindicator.IndicatorStatus.ACTIVE)
        self.ind.set_icon(APP_ICON_PANEL)
        file_grabber_icon = APP_ICON
        self.file_grabber = FileGrabber(
            file_grabber_icon, self.service.upload_callback
        )
        self.create_menu()
        # Setup hotkeys
        try:
            from gi.repository import Keybinder
            Keybinder.init()
            Keybinder.bind(self._keymap, self.grab_screen_area)
        except ImportError:
            pass

    def show_ind_menu(self, icon, button, time):
        self.menu.show_all()
        self.menu.popup(
            None, None, Gtk.status_icon_position_menu, button, time, self.ind
        )

    def read_settings(self):
        self.config = config = ConfigParser()
        try:
            self.config.read(CONFIG_FILE)
        except Exception as ex:
            log.error('Error: {}'.format(ex))
        else:
            try:
                self.SERVICE_NAME = config.get('SERVICE', 'name')
            except Exception as ex:
                log.error('Error: {}'.format(ex))
                self.SERVICE_NAME = DEFAULT_SERVICE_NAME
            try:
                self._keymap = config.get('KEYMAP', 'grabscreen')
            except Exception as ex:
                log.error('Error: {}'.format(ex))
                self._keymap = '<Super>P'
        self.service = globals()[self.SERVICE_NAME](
            self, self.config, CONFIG_FILE, log
        )

    def save_settings(self):
        self.service.save_settings()
        config = ConfigParser()
        try:
            if not config.has_section('KEYMAP'):
                config.add_section('KEYMAP')
            config.set('KEYMAP', 'grabscreen', self._keymap)
            with open(CONFIG_FILE, 'a') as configfile:
                os.chmod(CONFIG_FILE, stat.S_IRUSR | stat.S_IWUSR)
                config.write(configfile)
        except Exception as ex:
            log.error('Error: {}'.format(ex))

    def check_autostart(self):
        autostart_dir = os.path.join(
            os.path.expanduser('~'), '.config/autostart/'
        )
        autostart_file = 'indicator-fileshare.desktop'
        autostart_path = os.path.join(autostart_dir, autostart_file)
        if not os.path.isfile(autostart_path):
            # Look for desktop file
            desktop_file_path = None
            desktop_file_directory = '/usr/share/applications/'
            fullpath = os.path.normpath(
                os.path.join(desktop_file_directory, autostart_file))
            if os.path.isfile(fullpath):
                desktop_file_path = fullpath
            if desktop_file_path:
                # If we've found the desktop file, create symlink
                if not os.path.exists(autostart_dir):
                    os.mkdir(autostart_dir)
                if os.path.isdir(autostart_dir):
                    log.debug('Installing autostart file.')
                    os.symlink(desktop_file_path, autostart_path)

    def get_version(self):
        return VERSION

    def create_menu(self):
        self.menu = Gtk.Menu()
        # Create menu items
        #  Grab screen area
        screen_area_grab = Gtk.MenuItem('Select screen area to grab...')
        self.menu.append(screen_area_grab)
        screen_area_grab.connect('activate', self.grab_screen_area)
        screen_area_grab.show()

        #  Open current service site in the browser
        self.open_site_url = open_site_url = Gtk.MenuItem(
            'Open {}'.format(self.SERVICE_NAME))
        self.menu.append(open_site_url)
        open_site_url.connect('activate', self.open_site)
        open_site_url.show()

        #  Widget for grabbing files
        grab_files = Gtk.MenuItem('Show/hide File Grabber')
        grab_files.connect('activate', self.toggle_file_grabber)
        grab_files.show()
        self.menu.append(grab_files)

        #  Breaker
        breaker = Gtk.SeparatorMenuItem()
        breaker.show()
        self.menu.append(breaker)

        #  About
        about_show = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_ABOUT, None)
        about_show.connect('activate', self.about)
        about_show.show()
        self.menu.append(about_show)

        #  Breaker
        breaker = Gtk.SeparatorMenuItem()
        breaker.show()
        self.menu.append(breaker)

        #  Log in
        self.login_menu = Gtk.Menu()
        self.imgur_login_menu = Gtk.MenuItem('...to {}'.format(Imgur.__name__))
        self.imgur_login_menu.connect('activate', self.login,
                                      '{}'.format(Imgur.__name__))
        self.login_menu.append(self.imgur_login_menu)
        self.droplr_login_menu = Gtk.MenuItem(
            '...to {}'.format(Droplr.__name__))
        self.droplr_login_menu.connect('activate', self.login,
                                       '{}'.format(Droplr.__name__))
        self.droplr_login_menu.set_sensitive(False)
        self.login_menu.append(self.droplr_login_menu)
        self.login_menu.show_all()
        if not self.service.is_logged_in():
            self.auth = auth = Gtk.MenuItem('Log in...')
            self.auth.set_submenu(self.login_menu)
        else:
            if self.service.refresh_needed():
                self.service.refresh_access()  # is done to get username
            string = 'Log out ({}'.format(self.SERVICE_NAME)
            if self.service.get_username():
                string = '{}, {}'.format(string, self.service.get_username())
            string = '{})'.format(string)
            self.auth = auth = Gtk.MenuItem(string)
            self.auth_id = auth.connect('activate', self.logout)
        auth.show_all()
        self.menu.append(auth)

        #  Breaker
        breaker = Gtk.SeparatorMenuItem()
        breaker.show()
        self.menu.append(breaker)

        #  Quit
        quit = Gtk.ImageMenuItem.new_from_stock(Gtk.STOCK_QUIT, None)
        quit.connect('activate', self.quit)
        quit.show()
        self.menu.append(quit)
        self.ind.set_menu(self.menu)

    # def create_menu(self)

    def set_default_service(self):
        self.SERVICE_NAME = DEFAULT_SERVICE_NAME
        self.service = globals()[self.SERVICE_NAME](self, None, CONFIG_FILE,
                                                    log)
        self.open_site_url.set_label('Open {}'.format(self.SERVICE_NAME))

    def login(self, widget, *data):
        self.config.read(CONFIG_FILE)
        self.SERVICE_NAME = data[0]
        self.open_site_url.set_label('Open {}'.format(self.SERVICE_NAME))
        self.service = globals()[self.SERVICE_NAME](self, self.config,
                                                    CONFIG_FILE, log)
        self.service.login()
        if self.service.is_logged_in():
            log.debug('Logged in')
            string = 'Log out ({}'.format(self.SERVICE_NAME)
            if self.service.get_username():
                string = '{}, {}'.format(string, self.service.get_username())
            string = '{})'.format(string)
            self.auth.set_label(string)
            self.auth.set_submenu(None)
            self.auth_id = self.auth.connect('activate', self.logout)
            self.save_settings()
        else:
            self.set_default_service()
        self.file_grabber.set_upload_callback(self.service.upload_callback)
        return False

    def logout(self, widget):
        self.service.logout()
        log.debug('Logged out')
        self.save_settings()
        self.set_default_service()
        self.auth.set_label('Log in...')
        self.auth.disconnect(self.auth_id)
        self.auth.set_submenu(self.login_menu)
        self.save_settings()
        self.file_grabber.set_upload_callback(self.service.upload_callback)

    def grab_screen_area(self, widget):
        ScreenGrabber(self.service.upload_callback, self.quit, log)

    def open_site(self, widget):
        webbrowser.open(self.service.get_site_url())

    def toggle_file_grabber(self, widget):
        self.file_grabber.toggle_window()

    def about(self, widget):
        log.debug('Indicator: open About dialog')
        self.about_dialog = Gtk.AboutDialog()
        self.about_dialog.set_name('Fileshare Indicator')
        self.about_dialog.set_version(VERSION)

        ifile = open('/usr/share/doc/indicator-fileshare/AUTHORS', 'r')
        self.about_dialog.set_copyright(ifile.read().replace('\x0c', ''))
        ifile.close()

        self.about_dialog.set_website('http://aikikode.github.com/fileshare/')
        self.about_dialog.set_logo(GdkPixbuf.Pixbuf.new_from_file(APP_ICON))
        self.about_dialog.connect('response', self.about_close)
        self.about_dialog.show()

    def about_close(self, widget, event=None):
        log.debug('Indicator: closing About dialog')
        self.about_dialog.destroy()

    # Quit the applet
    def quit(self, widget=None, data=None):
        self.save_settings()
        log.debug('Indicator: Quitting')
        Gtk.main_quit()


def main():
    Gtk.main()
    return 0


if __name__ == '__main__':
    # Enable and configure logs
    global log
    cachedir = os.environ.get('XDG_CACHE_HOME', '').strip()
    if not cachedir:
        cachedir = os.path.expanduser('~/.cache')
    try:
        os.mkdir(cachedir)
    except OSError as e:
        if not (e.errno == errno.EEXIST and os.path.isdir(cachedir)):
            sys.exit('Unable to create cache directory')
    log_filename = os.path.join(cachedir, 'indicator-fileshare.log')
    log = logging.getLogger('IndicatorFileshare')
    log.propagate = False
    log.setLevel(logging.DEBUG)
    log_handler = logging.handlers.RotatingFileHandler(
        log_filename, maxBytes=1024 * 1024, backupCount=5
    )
    log_formatter = logging.Formatter(
        '[%(threadName)s] %(asctime)s - %(levelname)s - %(message)s'
    )
    log_handler.setFormatter(log_formatter)
    log.addHandler(log_handler)

    log.info('------------------------------')
    log.info('Started Fileshare Indicator')
    log.info('Fileshare Indicator version {}'.format(VERSION))

    # Single instance stuff for fileshare indicator
    myapp = SingleInstance(os.path.join(
        tempfile.gettempdir(),
        'indicator-fileshare-{}.pid'.format(getpass.getuser()))
    )
    # Check is another instance of same program running
    if myapp.is_already_running():
        log.info('Another instance of this program is already running')
        sys.exit('Another instance of this program is already running')

    di = IndicatorFileshare()
    main()