示例#1
0
文件: start.py 项目: hozn/coilmq
def _main(config=None, host=None, port=None, logfile=None, debug=None,
          daemon=None, uid=None, gid=None, pidfile=None, umask=None, rundir=None):

    # Note that we must initialize the configuration before we enter the context
    # block; however, we _cannot_ initialize logging until we are in the context block
    # (so we defer that until the context_serve call.)
    init_config(config)

    if host is not None:
        global_config.set('coilmq', 'listen_addr', host)

    if port is not None:
        global_config.set('coilmq', 'listen_port', str(port))

        if daemon and is_nt:
            warnings.warn("Daemon context is not available for NT platform")

    # in an on-daemon mode, we use a dummy context objectx
    # so we can use the same run-server code as the daemon version.
    context = pydaemon.DaemonContext(uid=uid,
                                     gid=gid,
                                     pidfile=pid.PidFile(pidname=pidfile) if pidfile else None,
                                     umask=int(umask, 8),
                                     working_directory=rundir) if daemon and pydaemon else contextmanager(lambda: (yield))()

    context_serve(context, config, host, port, logfile, debug, daemon, uid, gid, pidfile, umask, rundir)
def startSTOMPBroker(config, serverUpEvent, tries=-1, delay=1, backoff=1.5):
  """

  @param tries number of times to retry starting the broker. < 0 means infinitely many.
  @param delay number of seconds to wait after the first failed attempt
  @param backoff factor by which the delay will be incremented after a failure.
  """
  #stomp broker
  mtries = tries
  mdelay = delay
  coilserver = None
  from coilmq.config import config as coilconfig
  if config.has_section('coilmq'):
    for k,v in config.items('coilmq'):
      coilconfig.set('coilmq', k, v)
      logger.debug("Set %s to %s for coilmq config." % (k,v))
  while True:
    try:
      coilserver = coilmq.start.server_from_config(coilconfig)
      logger.info("Stomp server listening on %s:%s" % \
          coilserver.server_address)
      serverUpEvent.set()
      coilserver.serve_forever()
    except IOError as ex:
      logger.error("Exception while starting coilmq broker: '%s'", ex)
      if mtries != 0: 
        logger.debug("Retrying coilmq startup in %.1f seconds...", mdelay)
        time.sleep(mdelay)
        mdelay *= backoff
        mtries -= 1
      else:
        logger.debug("Ran out of trials (tried %d times) for coilmq startup. Giving up.", tries)
        break
    finally:
      if coilserver: coilserver.server_close()
示例#3
0
def startSTOMPBroker(config, serverUpEvent, tries=-1, delay=1, backoff=1.5):
    """

  @param tries number of times to retry starting the broker. < 0 means infinitely many.
  @param delay number of seconds to wait after the first failed attempt
  @param backoff factor by which the delay will be incremented after a failure.
  """
    #stomp broker
    mtries = tries
    mdelay = delay
    coilserver = None
    from coilmq.config import config as coilconfig
    if config.has_section('coilmq'):
        for k, v in config.items('coilmq'):
            coilconfig.set('coilmq', k, v)
            logger.debug("Set %s to %s for coilmq config." % (k, v))
    while True:
        try:
            coilserver = coilmq.start.server_from_config(coilconfig)
            logger.info("Stomp server listening on %s:%s" % \
                coilserver.server_address)
            serverUpEvent.set()
            coilserver.serve_forever()
        except IOError as ex:
            logger.error("Exception while starting coilmq broker: '%s'", ex)
            if mtries != 0:
                logger.debug("Retrying coilmq startup in %.1f seconds...",
                             mdelay)
                time.sleep(mdelay)
                mdelay *= backoff
                mtries -= 1
            else:
                logger.debug(
                    "Ran out of trials (tried %d times) for coilmq startup. Giving up.",
                    tries)
                break
        finally:
            if coilserver: coilserver.server_close()
示例#4
0
def _main(config=None,
          host=None,
          port=None,
          logfile=None,
          debug=None,
          daemon=None,
          uid=None,
          gid=None,
          pidfile=None,
          umask=None,
          rundir=None):

    # Note that we must initialize the configuration before we enter the context
    # block; however, we _cannot_ initialize logging until we are in the context block
    # (so we defer that until the context_serve call.)
    init_config(config)

    if host is not None:
        global_config.set('coilmq', 'listen_addr', host)

    if port is not None:
        global_config.set('coilmq', 'listen_port', str(port))

        if daemon and is_nt:
            warnings.warn("Daemon context is not available for NT platform")

    # in an on-daemon mode, we use a dummy context objectx
    # so we can use the same run-server code as the daemon version.
    context = pydaemon.DaemonContext(
        uid=uid,
        gid=gid,
        pidfile=pid.PidFile(pidname=pidfile) if pidfile else None,
        umask=int(umask, 8),
        working_directory=rundir) if daemon and pydaemon else contextmanager(
            lambda: (yield))()

    context_serve(context, config, host, port, logfile, debug, daemon, uid,
                  gid, pidfile, umask, rundir)
示例#5
0
    """
    m_tries = tries
    m_delay = delay
    m_server = None

    try:
        from coilmq.config import config as broker_config
        import coilmq.start
    except ImportError, e:
        print "Import error: %s\nPlease check." % e
        exit()

    if config.has_section('broker'):
        for (attribute, value) in config.items('broker'):
            if attribute != 'name':
                broker_config.set('coilmq', attribute, value)
                logger.debug("[coilmq] %s = %s" % (attribute, value))

    broker_server = None
    while True:
        try:
            broker_server = coilmq.start.server_from_config(broker_config)
            logger.info("Stomp server listening on %s:%s" %
                        broker_server.server_address)
            server_event.set()
            broker_server.serve_forever()
        except (KeyboardInterrupt, SystemExit):
            logger.info("Stomp server stopped by user interrupt.")
            raise SystemExit()
        except IOError as ex:
            logger.error("Exception while starting coilmq broker: '%s'", ex)
示例#6
0
def main():
    """
    Main entry point for running a socket server from the commandline.
    
    This method will read in options from the commandline and call the L{config.init_config} method
    to get everything setup.  Then, depending on whether deamon mode was specified or not, 
    the process may be forked (or not) and the server will be started.
    """

    parser = OptionParser()
    parser.add_option("-c", "--config", dest="configfile",
                      help="Read configuration from FILE. (CLI options override config file.)", metavar="FILE")
    
    parser.add_option("-b", "--host", dest="listen_addr",
                      help="Listen on specified address (default 0.0.0.0)", metavar="ADDR")
    
    parser.add_option("-p", "--port", dest="listen_port",
                      help="Listen on specified port (default 61613)", type="int", metavar="PORT")

    parser.add_option("-l", "--logfile", dest="logfile",
                      help="Log to specified file (unless logging configured in config file).", metavar="FILE")

    parser.add_option("--debug", action="store_true", dest="debug", default=False, 
                      help="Sets logging to debug (unless logging configured in config file).")
    
    parser.add_option("-d", "--daemon", action="store_true", dest="daemon", default=False,
                      help="Run server as a daemon (default False).")
    
    parser.add_option("-u", "--uid", dest="uid",
                      help="The user/UID to use for daemon process.", metavar="UID")
    
    parser.add_option("-g", "--gid", dest="gid",
                      help="The group/GID to use for daemon process.", metavar="GID")
    
    parser.add_option("--pidfile", dest="pidfile", help="The PID file to use.", metavar="FILE")
    
    parser.add_option("--umask", dest="umask",
                      help="Umask (octal) to apply for daemonized process.", metavar="MASK")
    
    parser.add_option('--rundir', dest="rundir",
                      help="The working directory to use for the daemonized process (default /).", metavar="DIR")
    
    (options, args) = parser.parse_args()
    
    # Note that we must initialize the configuration before we enter the context
    # block; however, we _cannot_ initialize logging until we are in the context block
    # (so we defer that until the context_serve call.)
    init_config(options.configfile)
    
    if options.listen_addr is not None:
        global_config.set('coilmq', 'listen_addr', options.listen_addr)
        
    if options.listen_port is not None:
        global_config.set('coilmq', 'listen_port', str(options.listen_port))
    
    if options.daemon:
        if not daemon_support:
            raise ConfigError("This environment/platform does not support running as daemon. (Are you running on *nix and did you install python-daemon package?)")
        else:
            
            context = daemon.DaemonContext()
            
            if options.uid is not None:
                context.uid = options.uid
                
            if options.gid is not None:
                context.gid = options.gid
                
            if options.pidfile is not None:
                context.pidfile = lockfile.FileLock(options.pidfile)
            
            if options.umask is not None:
                context.umask = int(options.umask, 8)
            
            if options.rundir is not None:
                context.working_directory = options.rundir
                
            context_serve(options, context)

    else:
        # Non-daemon mode, so we use a dummy context objectx
        # so we can use the same run-server code as the daemon version.
        
        class DumbContext(object):
            def __enter__(self):
                pass
            def __exit__(self, type, value, traceback):
                pass
        
        context_serve(options, DumbContext())
示例#7
0
def main():
    """
    Main entry point for running a socket server from the commandline.
    
    This method will read in options from the commandline and call the L{config.init_config} method
    to get everything setup.  Then, depending on whether deamon mode was specified or not, 
    the process may be forked (or not) and the server will be started.
    """

    parser = OptionParser()
    parser.add_option(
        "-c",
        "--config",
        dest="configfile",
        help=
        "Read configuration from FILE. (CLI options override config file.)",
        metavar="FILE")

    parser.add_option("-b",
                      "--host",
                      dest="listen_addr",
                      help="Listen on specified address (default 127.0.0.1)",
                      metavar="ADDR")

    parser.add_option("-p",
                      "--port",
                      dest="listen_port",
                      help="Listen on specified port (default 61613)",
                      type="int",
                      metavar="PORT")

    parser.add_option(
        "-l",
        "--logfile",
        dest="logfile",
        help=
        "Log to specified file (unless logging configured in config file).",
        metavar="FILE")

    parser.add_option(
        "--debug",
        action="store_true",
        dest="debug",
        default=False,
        help="Sets logging to debug (unless logging configured in config file)."
    )

    parser.add_option("-d",
                      "--daemon",
                      action="store_true",
                      dest="daemon",
                      default=False,
                      help="Run server as a daemon (default False).")

    parser.add_option("-u",
                      "--uid",
                      dest="uid",
                      help="The user/UID to use for daemon process.",
                      metavar="UID")

    parser.add_option("-g",
                      "--gid",
                      dest="gid",
                      help="The group/GID to use for daemon process.",
                      metavar="GID")

    parser.add_option("--pidfile",
                      dest="pidfile",
                      help="The PID file to use.",
                      metavar="FILE")

    parser.add_option("--umask",
                      dest="umask",
                      help="Umask (octal) to apply for daemonized process.",
                      metavar="MASK")

    parser.add_option(
        '--rundir',
        dest="rundir",
        help=
        "The working directory to use for the daemonized process (default /).",
        metavar="DIR")

    (options, args) = parser.parse_args()

    # Note that we must initialize the configuration before we enter the context
    # block; however, we _cannot_ initialize logging until we are in the context block
    # (so we defer that until the context_serve call.)
    init_config(options.configfile)

    if options.listen_addr is not None:
        global_config.set('coilmq', 'listen_addr', options.listen_addr)

    if options.listen_port is not None:
        global_config.set('coilmq', 'listen_port', str(options.listen_port))

    if options.daemon:
        if not daemon_support:
            raise ConfigError(
                "This environment/platform does not support running as daemon. (Are you running on *nix and did you install python-daemon package?)"
            )
        else:

            context = daemon.DaemonContext()

            if options.uid is not None:
                context.uid = options.uid

            if options.gid is not None:
                context.gid = options.gid

            if options.pidfile is not None:
                context.pidfile = lockfile.FileLock(options.pidfile)

            if options.umask is not None:
                context.umask = int(options.umask, 8)

            if options.rundir is not None:
                context.working_directory = options.rundir

            context_serve(options, context)

    else:
        # Non-daemon mode, so we use a dummy context objectx
        # so we can use the same run-server code as the daemon version.

        class DumbContext(object):
            def __enter__(self):
                pass

            def __exit__(self, type, value, traceback):
                pass

        context_serve(options, DumbContext())