def start(self): (self.__options, self.__args) = self.__parser.parse_args() if self.__options.quiet: self.__options.loglevel = "none" if self.__options.loglevel: self.__options.loglevel = self.__options.loglevel.lower() # Setup the logger deluge.log.setupLogger(level=self.__options.loglevel, filename=self.__options.logfile) log = deluge.log.LOG if self.__options.config: if not deluge.configmanager.set_config_dir(self.__options.config): log.error( "There was an error setting the config dir! Exiting..") sys.exit(1) setproctitle("deluge-%s" % self.__name) log.info("Deluge ui %s", deluge.common.get_version()) log.debug("options: %s", self.__options) log.debug("args: %s", self.__args) log.info("Starting %s ui..", self.__name)
def start(self): # Make sure all arguments are unicode argv = deluge.common.unicode_argv()[1:] (self.__options, self.__args) = self.__parser.parse_args(argv) if self.__options.quiet: self.__options.loglevel = "none" logfile_mode = 'w' if self.__options.rotate_logs: logfile_mode = 'a' if self.__options.loglevel: self.__options.loglevel = self.__options.loglevel.lower() # Setup the logger deluge.log.setupLogger(level=self.__options.loglevel, filename=self.__options.logfile, filemode=logfile_mode) log = logging.getLogger(__name__) if self.__options.config: if not deluge.configmanager.set_config_dir(self.__options.config): log.error("There was an error setting the config dir! Exiting..") sys.exit(1) setproctitle("deluge-%s" % self.__name) log.info("Deluge ui %s", deluge.common.get_version()) log.debug("options: %s", self.__options) log.debug("args: %s", self.__args) log.info("Starting %s ui..", self.__name)
def start(self): (self.__options, self.__args) = self.__parser.parse_args() if self.__options.quiet: self.__options.loglevel = "none" logfile_mode = 'w' if self.__options.rotate_logs: logfile_mode = 'a' # Setup the logger # Setup the logger deluge.log.setupLogger(level=self.__options.loglevel, filename=self.__options.logfile, filemode=logfile_mode) log = logging.getLogger(__name__) if self.__options.config: if not deluge.configmanager.set_config_dir(self.__options.config): log.error("There was an error setting the config dir! Exiting..") sys.exit(1) log.info("Deluge ui %s", deluge.common.get_version()) log.debug("options: %s", self.__options) log.debug("args: %s", self.__args) log.info("Starting ui..")
def start(self): if deluge.common.windows_check(): (self.__options, self.__args) = self.__parser.parse_args(deluge.common.win32_unicode_argv()[1:]) else: (self.__options, self.__args) = self.__parser.parse_args() if self.__options.quiet: self.__options.loglevel = "none" if self.__options.loglevel: self.__options.loglevel = self.__options.loglevel.lower() # Setup the logger deluge.log.setupLogger(level=self.__options.loglevel, filename=self.__options.logfile) log = deluge.log.LOG if self.__options.config: if not deluge.configmanager.set_config_dir(self.__options.config): log.error("There was an error setting the config dir! Exiting..") sys.exit(1) setproctitle("deluge-%s" % self.__name) log.info("Deluge ui %s", deluge.common.get_version()) log.debug("options: %s", self.__options) log.debug("args: %s", self.__args) log.info("Starting %s ui..", self.__name)
def start(self): # Make sure all arguments are unicode argv = deluge.common.unicode_argv()[1:] (self.__options, self.__args) = self.__parser.parse_args(argv) if self.__options.quiet: self.__options.loglevel = "none" logfile_mode = 'w' if self.__options.rotate_logs: logfile_mode = 'a' if self.__options.loglevel: self.__options.loglevel = self.__options.loglevel.lower() # Setup the logger deluge.log.setupLogger(level=self.__options.loglevel, filename=self.__options.logfile, filemode=logfile_mode) log = logging.getLogger(__name__) if self.__options.config: if not deluge.configmanager.set_config_dir(self.__options.config): log.error( "There was an error setting the config dir! Exiting..") sys.exit(1) setproctitle("deluge-%s" % self.__name) log.info("Deluge ui %s", deluge.common.get_version()) log.debug("options: %s", self.__options) log.debug("args: %s", self.__args) log.info("Starting %s ui..", self.__name)
def start(self): (self.__options, self.__args) = self.__parser.parse_args() if self.__options.quiet: self.__options.loglevel = "none" logfile_mode = 'w' if self.__options.rotate_logs: logfile_mode = 'a' # Setup the logger # Setup the logger deluge.log.setupLogger(level=self.__options.loglevel, filename=self.__options.logfile, filemode=logfile_mode) deluge.common.setup_translations() log = logging.getLogger(__name__) if self.__options.config: if not deluge.configmanager.set_config_dir(self.__options.config): log.error( "There was an error setting the config dir! Exiting..") sys.exit(1) log.info("Deluge ui %s", deluge.common.get_version()) log.debug("options: %s", self.__options) log.debug("args: %s", self.__args) log.info("Starting ui..")
def start_ui(): """Entry point for ui script""" import deluge.common # Setup the argument parser parser = OptionParser(usage="%prog [options] [actions]") parser.add_option("-v", "--version", action="callback", callback=version_callback, help="Show program's version number and exit") parser.add_option("-u", "--ui", dest="ui", help="""The UI that you wish to launch. The UI choices are:\n \t gtk -- A GTK-based graphical user interface (default)\n \t web -- A web-based interface (http://localhost:8112)\n \t console -- A console or command-line interface""", action="store", type="str") parser.add_option("-s", "--set-default-ui", dest="default_ui", help="Sets the default UI to be run when no UI is specified", action="store", type="str") parser.add_option("-a", "--args", dest="args", help="Arguments to pass to UI, -a '--option args'", action="store", type="str") parser.add_option("-c", "--config", dest="config", help="Set the config folder location", action="store", type="str") parser.add_option("-l", "--logfile", dest="logfile", help="Output to designated logfile instead of stdout", action="store", type="str") parser.add_option("-L", "--loglevel", dest="loglevel", help="Set the log level: none, info, warning, error, critical, debug", action="store", type="str") parser.add_option("-q", "--quiet", dest="quiet", help="Sets the log level to 'none', this is the same as `-L none`", action="store_true", default=False) # Get the options and args from the OptionParser if deluge.common.windows_check(): (options, args) = parser.parse_args(deluge.common.win32_unicode_argv()[1:]) else: (options, args) = parser.parse_args() # Setup the logger if options.quiet: options.loglevel = "none" if options.loglevel: options.loglevel = options.loglevel.lower() deluge.log.setupLogger(level=options.loglevel, filename=options.logfile) from deluge.log import LOG as log if options.config: if not os.path.exists(options.config): # Try to create the config folder if it doesn't exist try: os.makedirs(options.config) except Exception, e: pass elif not os.path.isdir(options.config): log.error("Config option needs to be a directory!") sys.exit(1)
def set_config_dir(self, directory): """ Sets the config directory. :param directory: str, the directory where the config info should be :returns bool: True if successfully changed directory, False if not """ if not directory: return False # Ensure absolute dirpath directory = os.path.abspath(directory) log.info('Setting config directory to: %s', directory) if not os.path.exists(directory): # Try to create the config folder if it doesn't exist try: os.makedirs(directory) except OSError as ex: log.error('Unable to make config directory: %s', ex) return False elif not os.path.isdir(directory): log.error('Config directory needs to be a directory!') return False self.__config_directory = directory # Reset the config_files so we don't get config from old config folder # XXX: Probably should have it go through the config_files dict and try # to reload based on the new config directory self.save() self.config_files = {} deluge.log.tweak_logging_levels() return True
def __init__(self, options, args, ui_args): from deluge.log import LOG as log log.debug("UI init..") # Set the config directory deluge.configmanager.set_config_dir(options.config) config = deluge.configmanager.ConfigManager("ui.conf", DEFAULT_PREFS) if not options.ui: selected_ui = config["default_ui"] else: selected_ui = options.ui setproctitle("deluge") config.save() del config try: if selected_ui == "gtk": log.info("Starting GtkUI..") from deluge.ui.gtkui.gtkui import GtkUI ui = GtkUI(args) elif selected_ui == "web": log.info("Starting WebUI..") from deluge.ui.web.web import WebUI ui = WebUI(args) elif selected_ui == "console": log.info("Starting ConsoleUI..") from deluge.ui.console.main import ConsoleUI ui = ConsoleUI(ui_args) except ImportError, e: import sys import traceback error_type, error_value, tb = sys.exc_info() stack = traceback.extract_tb(tb) last_frame = stack[-1] if last_frame[0] == __file__: log.error( "Unable to find the requested UI: %s. Please select a different UI with the '-u' option or alternatively use the '-s' option to select a different default UI.", selected_ui, ) else: log.exception(e) log.error("There was an error whilst launching the request UI: %s", selected_ui) log.error("Look at the traceback above for more information.") sys.exit(1)
def __init__(self, options, args, ui_args): import logging log = logging.getLogger(__name__) log.debug("UI init..") # Set the config directory deluge.configmanager.set_config_dir(options.config) config = deluge.configmanager.ConfigManager("ui.conf", DEFAULT_PREFS) if not options.ui: selected_ui = config["default_ui"] else: selected_ui = options.ui setproctitle("deluge") config.save() del config try: if selected_ui == "gtk": log.info("Starting GtkUI..") from deluge.ui.gtkui.gtkui import GtkUI ui = GtkUI(args) elif selected_ui == "web": log.info("Starting WebUI..") from deluge.ui.web.web import WebUI ui = WebUI(args) elif selected_ui == "console": log.info("Starting ConsoleUI..") from deluge.ui.console.main import ConsoleUI ui = ConsoleUI(ui_args) except ImportError, e: import sys import traceback error_type, error_value, tb = sys.exc_info() stack = traceback.extract_tb(tb) last_frame = stack[-1] if last_frame[0] == __file__: log.error( "Unable to find the requested UI: %s. Please select a different UI with the '-u' option or alternatively use the '-s' option to select a different default UI.", selected_ui) else: log.exception(e) log.error( "There was an error whilst launching the request UI: %s", selected_ui) log.error("Look at the traceback above for more information.") sys.exit(1)
if options.quiet: options.loglevel = "none" if options.logfile: # Try to create the logfile's directory if it doesn't exist try: os.makedirs(os.path.abspath(os.path.dirname(options.logfile))) except OSError, e: if e.errno != EEXIST: print "There was an error creating the log directory, exiting... (%s)" % e sys.exit(1) deluge.log.setupLogger(level=options.loglevel, filename=options.logfile) from deluge.log import LOG as log if options.config: if not deluge.configmanager.set_config_dir(options.config): log.error("There was an error setting the config directory! Exiting...") sys.exit(1) # Sets the options.logfile to point to the default location def open_logfile(): if not options.logfile: options.logfile = deluge.configmanager.get_config_dir("deluged.log") file_handler = FileHandler(options.logfile) log.addHandler(file_handler) # Writes out a pidfile if necessary def write_pidfile(): if options.pidfile: open(options.pidfile, "wb").write("%s\n" % os.getpid()) # If the donot daemonize is set, then we just skip the forking
def _handle_ui_options(self, options): """Handle UI common and process group options. Args: options (argparse.Namespace): The parsed options. Returns: argparse.Namespace: The parsed options. """ if not self.common_setup: self.common_setup = True # Setup the logger if options.quiet: options.loglevel = 'none' if options.loglevel: options.loglevel = options.loglevel.lower() logfile_mode = 'w' logrotate = options.logrotate if options.logrotate: logfile_mode = 'a' logrotate = common.parse_human_size(options.logrotate) # Setup the logger deluge.log.setup_logger( level=options.loglevel, filename=options.logfile, filemode=logfile_mode, logrotate=logrotate, output_stream=self.log_stream, ) if options.config: if not set_config_dir(options.config): log = logging.getLogger(__name__) log.error( 'There was an error setting the config dir! Exiting..') sys.exit(1) else: if not os.path.exists(common.get_default_config_dir()): os.makedirs(common.get_default_config_dir()) if self.process_arg_group: self.process_arg_group = False # If donotdaemonize is set, skip process forking. if not (common.windows_check() or options.donotdaemonize): if os.fork(): os._exit(0) os.setsid() # Do second fork if os.fork(): os._exit(0) # Ensure process doesn't keep any directory in use that may prevent a filesystem unmount. os.chdir(get_config_dir()) # Write pid file before chuid if options.pidfile: with open(options.pidfile, 'w') as _file: _file.write('%d\n' % os.getpid()) if not common.windows_check(): if options.group: if not options.group.isdigit(): import grp options.group = grp.getgrnam(options.group)[2] os.setgid(options.group) if options.user: if not options.user.isdigit(): import pwd options.user = pwd.getpwnam(options.user)[2] os.setuid(options.user) return options
def _handle_ui_options(self, options): """Handle UI common and process group options. Args: options (argparse.Namespace): The parsed options. Returns: argparse.Namespace: The parsed options. """ if not self.common_setup: self.common_setup = True # Setup the logger if options.quiet: options.loglevel = 'none' if options.loglevel: options.loglevel = options.loglevel.lower() logfile_mode = 'w' logrotate = options.logrotate if options.logrotate: logfile_mode = 'a' logrotate = common.parse_human_size(options.logrotate) # Setup the logger deluge.log.setup_logger(level=options.loglevel, filename=options.logfile, filemode=logfile_mode, logrotate=logrotate, output_stream=self.log_stream) if options.config: if not set_config_dir(options.config): log = logging.getLogger(__name__) log.error('There was an error setting the config dir! Exiting..') sys.exit(1) else: if not os.path.exists(common.get_default_config_dir()): os.makedirs(common.get_default_config_dir()) if self.process_arg_group: self.process_arg_group = False # If donotdaemonize is set, skip process forking. if not (common.windows_check() or options.donotdaemonize): if os.fork(): os._exit(0) os.setsid() # Do second fork if os.fork(): os._exit(0) # Ensure process doesn't keep any directory in use that may prevent a filesystem unmount. os.chdir(get_config_dir()) # Write pid file before chuid if options.pidfile: with open(options.pidfile, 'wb') as _file: _file.write('%d\n' % os.getpid()) if not common.windows_check(): if options.user: if not options.user.isdigit(): import pwd options.user = pwd.getpwnam(options.user)[2] os.setuid(options.user) if options.group: if not options.group.isdigit(): import grp options.group = grp.getgrnam(options.group)[2] os.setuid(options.group) return options
if options.quiet: options.loglevel = "none" if options.logfile: # Try to create the logfile's directory if it doesn't exist try: os.makedirs(os.path.abspath(os.path.dirname(options.logfile))) except OSError, e: if e.errno != EEXIST: print "There was an error creating the log directory, exiting... (%s)" % e sys.exit(1) deluge.log.setupLogger(level=options.loglevel, filename=options.logfile) from deluge.log import LOG as log if options.config: if not deluge.configmanager.set_config_dir(options.config): log.error( "There was an error setting the config directory! Exiting...") sys.exit(1) # Sets the options.logfile to point to the default location def open_logfile(): if not options.logfile: options.logfile = deluge.configmanager.get_config_dir( "deluged.log") file_handler = FileHandler(options.logfile) log.addHandler(file_handler) # Writes out a pidfile if necessary def write_pidfile(): if options.pidfile: open(options.pidfile, "wb").write("%s\n" % os.getpid())
def start_daemon(): """Entry point for daemon script""" import deluge.common if 'dev' not in deluge.common.get_version(): import warnings warnings.filterwarnings('ignore', category=DeprecationWarning, module='twisted') # Setup the argument parser parser = OptionParser(usage="%prog [options] [actions]", version=deluge.common.get_version()) parser.add_option("-p", "--port", dest="port", help="Port daemon will listen on", action="store", type="int") parser.add_option("-i", "--interface", dest="interface", help="Interface daemon will listen for bittorrent connections on, \ this should be an IP address", metavar="IFACE", action="store", type="str") parser.add_option("-u", "--ui-interface", dest="ui_interface", help="Interface daemon will listen for UI connections on, this should be\ an IP address", metavar="IFACE", action="store", type="str") if not (deluge.common.windows_check() or deluge.common.osx_check()): parser.add_option("-d", "--do-not-daemonize", dest="donot", help="Do not daemonize", action="store_true", default=False) parser.add_option("-c", "--config", dest="config", help="Set the config location", action="store", type="str") parser.add_option("-l", "--logfile", dest="logfile", help="Set the logfile location", action="store", type="str") parser.add_option("-P", "--pidfile", dest="pidfile", help="Use pidfile to store process id", action="store", type="str") if not deluge.common.windows_check(): parser.add_option("-U", "--user", dest="user", help="User to switch to. Only use it when starting as root", action="store", type="str") parser.add_option("-g", "--group", dest="group", help="Group to switch to. Only use it when starting as root", action="store", type="str") parser.add_option("-L", "--loglevel", dest="loglevel", help="Set the log level: none, info, warning, error, critical, debug", action="store", type="str") parser.add_option("-q", "--quiet", dest="quiet", help="Sets the log level to 'none', this is the same as `-L none`", action="store_true", default=False) parser.add_option("-r", "--rotate-logs", help="Rotate logfiles.", action="store_true", default=False) parser.add_option("--profile", dest="profile", action="store_true", default=False, help="Profiles the daemon") # Get the options and args from the OptionParser (options, args) = parser.parse_args() if options.quiet: options.loglevel = "none" logfile_mode = 'w' if options.rotate_logs: logfile_mode = 'a' # Setup the logger deluge.log.setupLogger(level=options.loglevel, filename=options.logfile, filemode=logfile_mode) deluge.common.setup_translations() import deluge.configmanager if options.config: if not deluge.configmanager.set_config_dir(options.config): print("There was an error setting the config dir! Exiting..") sys.exit(1) # Sets the options.logfile to point to the default location def open_logfile(): if not options.logfile: options.logfile = deluge.configmanager.get_config_dir("deluged.log") # Writes out a pidfile if necessary def write_pidfile(): if options.pidfile: open(options.pidfile, "wb").write("%s\n" % os.getpid()) # If the donot daemonize is set, then we just skip the forking if not (deluge.common.windows_check() or deluge.common.osx_check() or options.donot): if os.fork(): # We've forked and this is now the parent process, so die! os._exit(0) os.setsid() # Do second fork if os.fork(): os._exit(0) # Write pid file before chuid write_pidfile() if options.user: if not options.user.isdigit(): import pwd options.user = pwd.getpwnam(options.user)[2] os.setuid(options.user) if options.group: if not options.group.isdigit(): import grp options.group = grp.getgrnam(options.group)[2] os.setuid(options.group) open_logfile() # Setup the logger try: # Try to make the logfile's directory if it doesn't exist os.makedirs(os.path.abspath(os.path.dirname(options.logfile))) except: pass import logging log = logging.getLogger(__name__) if options.profile: import hotshot hsp = hotshot.Profile(deluge.configmanager.get_config_dir("deluged.profile")) hsp.start() try: from deluge.core.daemon import Daemon Daemon(options, args) except deluge.error.DaemonRunningError, e: log.error(e) log.error("You cannot run multiple daemons with the same config directory set.") log.error("If you believe this is an error, you can force a start by deleting %s.", deluge.configmanager.get_config_dir("deluged.pid")) sys.exit(1)
def start_daemon(): """Entry point for daemon script""" import deluge.common deluge.common.setup_translations() if 'dev' not in deluge.common.get_version(): import warnings warnings.filterwarnings('ignore', category=DeprecationWarning, module='twisted') # Setup the argument parser parser = OptionParser(usage="%prog [options] [actions]", version= "%prog: " + deluge.common.get_version() + lt_version) parser.add_option("-p", "--port", dest="port", help="Port daemon will listen on", action="store", type="int") parser.add_option("-i", "--interface", dest="interface", help="Interface daemon will listen for bittorrent connections on, \ this should be an IP address", metavar="IFACE", action="store", type="str") parser.add_option("-u", "--ui-interface", dest="ui_interface", help="Interface daemon will listen for UI connections on, this should be\ an IP address", metavar="IFACE", action="store", type="str") if not (deluge.common.windows_check() or deluge.common.osx_check()): parser.add_option("-d", "--do-not-daemonize", dest="donot", help="Do not daemonize", action="store_true", default=False) parser.add_option("-c", "--config", dest="config", help="Set the config location", action="store", type="str") parser.add_option("-l", "--logfile", dest="logfile", help="Set the logfile location", action="store", type="str") parser.add_option("-P", "--pidfile", dest="pidfile", help="Use pidfile to store process id", action="store", type="str") if not deluge.common.windows_check(): parser.add_option("-U", "--user", dest="user", help="User to switch to. Only use it when starting as root", action="store", type="str") parser.add_option("-g", "--group", dest="group", help="Group to switch to. Only use it when starting as root", action="store", type="str") parser.add_option("-L", "--loglevel", dest="loglevel", help="Set the log level: none, info, warning, error, critical, debug", action="store", type="str") parser.add_option("-q", "--quiet", dest="quiet", help="Sets the log level to 'none', this is the same as `-L none`", action="store_true", default=False) parser.add_option("-r", "--rotate-logs", help="Rotate logfiles.", action="store_true", default=False) parser.add_option("--profile", dest="profile", action="store_true", default=False, help="Profiles the daemon") # Get the options and args from the OptionParser (options, args) = parser.parse_args() if options.quiet: options.loglevel = "none" logfile_mode = 'w' if options.rotate_logs: logfile_mode = 'a' # Setup the logger deluge.log.setupLogger(level=options.loglevel, filename=options.logfile, filemode=logfile_mode) import deluge.configmanager if options.config: if not deluge.configmanager.set_config_dir(options.config): print("There was an error setting the config dir! Exiting..") sys.exit(1) # Sets the options.logfile to point to the default location def open_logfile(): if not options.logfile: options.logfile = deluge.configmanager.get_config_dir("deluged.log") # Writes out a pidfile if necessary def write_pidfile(): if options.pidfile: open(options.pidfile, "wb").write("%s\n" % os.getpid()) # If the donot daemonize is set, then we just skip the forking if not (deluge.common.windows_check() or deluge.common.osx_check() or options.donot): if os.fork(): # We've forked and this is now the parent process, so die! os._exit(0) os.setsid() # Do second fork if os.fork(): os._exit(0) # Write pid file before chuid write_pidfile() if options.user: if not options.user.isdigit(): import pwd options.user = pwd.getpwnam(options.user)[2] os.setuid(options.user) if options.group: if not options.group.isdigit(): import grp options.group = grp.getgrnam(options.group)[2] os.setuid(options.group) open_logfile() # Setup the logger try: # Try to make the logfile's directory if it doesn't exist os.makedirs(os.path.abspath(os.path.dirname(options.logfile))) except: pass import logging log = logging.getLogger(__name__) if options.profile: import hotshot hsp = hotshot.Profile(deluge.configmanager.get_config_dir("deluged.profile")) hsp.start() try: from deluge.core.daemon import Daemon Daemon(options, args) except deluge.error.DaemonRunningError, e: log.error(e) log.error("You cannot run multiple daemons with the same config directory set.") log.error("If you believe this is an error, you can force a start by deleting %s.", deluge.configmanager.get_config_dir("deluged.pid")) sys.exit(1)
def start_daemon(): """Entry point for daemon script""" import deluge.common if 'dev' not in deluge.common.get_version(): import warnings warnings.filterwarnings('ignore', category=DeprecationWarning, module='twisted') # Setup the argument parser parser = OptionParser(usage="%prog [options] [actions]") parser.add_option("-v", "--version", action="callback", callback=version_callback, help="Show program's version number and exit") parser.add_option("-p", "--port", dest="port", help="Port daemon will listen on", action="store", type="int") parser.add_option("-i", "--interface", dest="listen_interface", help="Interface daemon will listen for bittorrent connections on, \ this should be an IP address", metavar="IFACE", action="store", type="str") parser.add_option("-u", "--ui-interface", dest="ui_interface", help="Interface daemon will listen for UI connections on, this should be\ an IP address", metavar="IFACE", action="store", type="str") parser.add_option("-d", "--do-not-daemonize", dest="donot", help="Do not daemonize", action="store_true", default=False) parser.add_option("-c", "--config", dest="config", help="Set the config location", action="store", type="str") parser.add_option("-P", "--pidfile", dest="pidfile", help="Use pidfile to store process id", action="store", type="str") parser.add_option("-l", "--logfile", dest="logfile", help="Set the logfile location", action="store", type="str") parser.add_option("-L", "--loglevel", dest="loglevel", help="Set the log level: none, info, warning, error, critical, debug", action="store", type="str") parser.add_option("-q", "--quiet", dest="quiet", help="Sets the log level to 'none', this is the same as `-L none`", action="store_true", default=False) parser.add_option("--profile", dest="profile", action="store_true", default=False, help="Profiles the daemon") # Get the options and args from the OptionParser (options, args) = parser.parse_args() if options.quiet: options.loglevel = "none" if options.config: if not deluge.configmanager.set_config_dir(options.config): print("There was an error setting the config dir! Exiting..") sys.exit(1) # Sets the options.logfile to point to the default location def open_logfile(): if not options.logfile: options.logfile = deluge.configmanager.get_config_dir("deluged.log") # Writes out a pidfile if necessary def write_pidfile(): if options.pidfile: open(options.pidfile, "wb").write("%s\n" % os.getpid()) # If the donot daemonize is set, then we just skip the forking if not options.donot: # Windows check, we log to the config folder by default if deluge.common.windows_check() or deluge.common.osx_check(): open_logfile() write_pidfile() else: if os.fork() == 0: os.setsid() if os.fork() == 0: open_logfile() write_pidfile() else: os._exit(0) else: os._exit(0) else: # Do not daemonize write_pidfile() # Setup the logger try: # Try to make the logfile's directory if it doesn't exist os.makedirs(os.path.abspath(os.path.dirname(options.logfile))) except: pass deluge.log.setupLogger(level=options.loglevel, filename=options.logfile) from deluge.log import LOG as log if options.profile: import hotshot hsp = hotshot.Profile(deluge.configmanager.get_config_dir("deluged.profile")) hsp.start() try: from deluge.core.daemon import Daemon Daemon(options, args) except deluge.error.DaemonRunningError, e: log.error(e) log.error("You cannot run multiple daemons with the same config directory set.") log.error("If you believe this is an error, you can force a start by deleting %s.", deluge.configmanager.get_config_dir("deluged.pid")) sys.exit(1)