# This file is part of stov, written by Helmut Pozimski 2012-2017. # # stov 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, version 2 of the License. # # stov 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 stov. If not, see . # -*- coding: utf8 -*- """ This module contains several functions that are necessary to set up the application. """ import gettext import os import sys import signal import argparse import logging from distutils.spawn import find_executable from lib_stov import stov_exceptions from lib_stov import configuration from lib_stov import database LOGGER = logging.getLogger("stov") def initialize_gettext(): """ Installs gettext so localization can be used if necessary. """ # Determine the path where the stov files are for localization locale_path = os.path.join(sys.path[0] + "/locale") if gettext.find("stov", locale_path) is None: base_path = os.path.split(sys.path[0])[0] if "share" in base_path: locale_path = os.path.join(base_path, "locale") else: locale_path = os.path.join(base_path, "share/locale") # Initialize gettext to support translation of the program try: trans = gettext.translation("stov", locale_path) except IOError: gettext.install("stov") if os.environ["LANG"] != "C" and os.environ["LANGUAGE"] != "C": print(_("The translation files could not be found, localization " "won't be available"), file=sys.stderr) else: trans.install() def sighandler(signum, frame): """Handler function for signals caught by stov.""" if signum == 2: print(_("STRG+C has been pressed, quitting..."), file=sys.stderr) elif signum == 15: print(_("Received SIGTERM, quitting..."), file=sys.stderr) os.killpg(os.getpid(), 1) remove_lock() sys.exit(0) def setup_sighandler(): """ Installs a signal handler to catch external signals """ signal.signal(signal.SIGTERM, sighandler) signal.signal(signal.SIGINT, sighandler) def parse_arguments(): """ Uses the argument parser to parse command line arguments and return them :return: parsed arguments :rtype: argparser.ArgumentParser """ parser = argparse.ArgumentParser(conflict_handler="resolve") parser.add_argument("-h", "--help", action="store_true", dest="help", help=_("show this help message and exit")) parser.add_argument("-a", "--add", dest="add", action="store_true", help=_("Add a new subscription (requires either \ --search, --channel or --playlist)")) parser.add_argument("-p", "--playlist", dest="playlist", help=_("Add a new Playlist subscription (requires " "add)")) parser.add_argument("-l", "--lssubs", action="store_true", dest="list", help=_("List the currently available subscriptions")) parser.add_argument("-r", "--remove", type=int, dest="deleteid", help=_("remove a subscription")) parser.add_argument("-u", "--update", action="store_true", dest="update", help=_( "update the information about the available " "videos")) parser.add_argument("-d", "--download", action="store_true", dest="download", help=_("download all available " "videos which haven't already" " been downloaded")) parser.add_argument("-s", "--search", dest="searchparameter", help=_("optionally add a search string to a new " "channel subscription or create a new search" " subscription (requires --add)")) parser.add_argument("-l", "--lsvids", type=int, dest="subscriptionid", help=_("Print all videos from a subscription")) parser.add_argument("-c", "--catchup", dest="catchup", help=_("Mark all videos from one channel as read \ (requires subscription-id as argument)")) parser.add_argument("-c", "--channel", dest="channel", help=_("specify a channel for a new subscription " "(requires --add)")) parser.add_argument("-l", "--license", dest="license", action="store_true", help=_("show the license of the program")) parser.add_argument("-v", "--version", dest="version", action="store_true", help=_("show the current running version number")) parser.add_argument("-q", "--quiet", dest="quiet", action="store_true", help=_("Suppress all output")) parser.add_argument("-v", "--verbose", dest="verbose", action="store_true", help=_("Be verbose and print also diagnostic " "messages")) parser.add_argument("-c", "--clean-database", dest="cleanup", action="store_true", help=_("Clean the database of entries " "no longer listed in the current API response")) parser.add_argument("-e", "--enable", type=int, dest="enableid", help=_("enables the subscription with the " "provided ID")) parser.add_argument("--disable", type=int, dest="disableid", help=_("disables the subscription with the " "provided ID")) parser.add_argument("-s", "--site", dest="site", help=_("specify the site to work with (for --add)")) parser.add_argument("--lssites", dest="lssites", action="store_true", help=_("list the supported sites")) return parser def create_lock(): """ Creates the lock file for stov. """ if os.access("/tmp/stov.lock", os.F_OK): try: lock_file = open("/tmp/stov.lock", "r") except IOError: LOGGER.error(_("The lock file could not be opened, please " "check that it exists and is readable, " "quitting now")) sys.exit(1) old_pid = lock_file.read().strip() if os.access("/proc/" + old_pid, os.F_OK): LOGGER.error(_("The lock file already exists, probably another " "instance of this program is already running\n" "if you are sure this is not the case, delete it " "manually and try again!")) sys.exit(1) lock_file.close() if not os.access("/proc/" + old_pid, os.F_OK): try: os.remove("/tmp/stov.lock") except os.error: LOGGER.error(_("The old lock file could not be deleted!")) try: LOCK_FILE = open("/tmp/stov.lock", "w") LOCK_FILE.write(str(os.getpid())) LOCK_FILE.close() except IOError: print(_("The lock file could not be created, please check that /tmp" " is writable and properly configured, quitting now."), file=sys.stderr) sys.exit(1) def remove_lock(): """ Removes the lock file when exiting the application. """ try: os.remove("/tmp/stov.lock") sys.exit(0) except os.error: LOGGER.error(_("Could not delete the lock file. Please check what " "went wrong and clean up manually!")) sys.exit(1) def setup_configuration(args): """ Reads the configuration and sets it up to be used within the application. :param args: command line arguments :return: configuration object :rtype: lib_stov.configuration.Conf """ if not os.access(os.environ['HOME'] + "/.stov", os.F_OK & os.W_OK): print(_("This seems to be the first time you run the programm, do " "you want to run the interactive assistant? (yes/no)")) conf = configuration.Conf() logger = conf.configure_logging(args.verbose, args.quiet) temp_input = input() if temp_input == "yes": conf.assist() try: conf.initialize() except stov_exceptions.ConfigFileWriteErrorException as error: logger.error(error) else: logger.info(_("Writing initial configuration according to " "your input, have fun!")) else: logger.info(_("Writing initial configuration according to default" " values.")) logger.debug(_("Creating hidden directory in home for " "configuration and database.")) try: conf.initialize() except stov_exceptions.DirectoryCreationFailedException as error: logger.error(error) except stov_exceptions.ConfigFileWriteErrorException as error: logger.error(error) else: conf = configuration.Conf() logger = conf.configure_logging(args.verbose, args.quiet) if os.access(str(os.environ['HOME']) + "/.stov/stov.config", os.F_OK): logger.debug(_("Migrating configuration from plain text to json.")) conf.migrate_config() try: logger.debug( _("Comparing current and running configuration version.")) check_result = conf.check_config() except stov_exceptions.ConfigFileReadErrorException as error: logger.error(error) sys.exit(1) except stov_exceptions.InvalidConfigurationVersionException as error: logger.error(error) sys.exit(1) else: if not check_result: logger.info( _("Your configuration needs to be updated, performing" " update now.")) try: conf.update_config() except stov_exceptions.ConfigFileReadErrorException as error: logger.error(error) sys.exit(1) except stov_exceptions.ConfigFileWriteErrorException as error: logger.error(error) sys.exit(1) return conf def setup_database(conf): """ Sets up the database and provides a DB object to talk to the database in the application. :param conf: configuration object :type conf: lib_stov.configuration.Conf :return: database object :rtype: lib_stov.database.Db """ if os.access(conf.dbpath, os.F_OK): try: db = database.Db(path=conf.dbpath, version=conf.values["db_version"]) except stov_exceptions.DBConnectionFailedException as error: LOGGER.error(error) sys.exit(1) else: try: db = database.Db(path=conf.dbpath, version=conf.values["db_version"]) except stov_exceptions.DBConnectionFailedException as error: LOGGER.error(error) sys.exit(1) else: try: db.populate() except stov_exceptions.DBWriteAccessFailedException as error: LOGGER.error(error) sys.exit(1) else: LOGGER.debug(_("Created initial database tables.")) try: conf = configuration.Conf() LOGGER.debug(_("Comparing current and running database version.")) if not conf.check_db(): LOGGER.info( _("Your database needs to be updated, performing update " "now.")) db.update() conf.values["db_version"] = db.get_version() LOGGER.debug("Opening configuration file.") try: conf.write_config() except stov_exceptions.ConfigFileWriteErrorException as error: LOGGER.error(error) except stov_exceptions.DBWriteAccessFailedException as error: LOGGER.error(error) sys.exit(1) return db def find_youtubedl(conf): """ Tries to find youtube-dl and writes it's path to the configuration file :param conf: configuration object :type conf: lib_stov.configuration.Conf """ if conf.values["youtube-dl"] == "": youtubedl_path = find_executable("youtube-dl") conf.values["youtube-dl"] = youtubedl_path if os.access(conf.values["youtube-dl"], os.F_OK & os.R_OK & os.X_OK): LOGGER.info(_("Found youtube-dl, writing it's path to the " "configuration file.")) LOGGER.debug("Opening configuration file.") try: conf.write_config() except stov_exceptions.ConfigFileWriteErrorException as error: LOGGER.error(error) sys.exit(1) else: LOGGER.error( _("Could not find youtube-dl, it either does not exist, " "is not readable or not executable. Please note that " "youtube-dl is not needed for the program to run but " "is needed to use the download option which won't work " "otherwise. If youtube-dl isn't found automatically, " "you may also enter the path to it in the configuration" " file."))