Python serving.make_server函数代码示例

def make_simple_server(tb_app, host, port):
  """Create an HTTP server for TensorBoard.

  Args:
    tb_app: The TensorBoard WSGI application to create a server for.
    host: Indicates the interfaces to bind to ('::' or '0.0.0.0' for all
        interfaces, '::1' or '127.0.0.1' for localhost). A blank value ('')
        indicates protocol-agnostic all interfaces.
    port: The port to bind to (0 indicates an unused port selected by the
        operating system).
  Returns:
    A tuple of (server, url):
      server: An HTTP server object configured to host TensorBoard.
      url: A best guess at a URL where TensorBoard will be accessible once the
        server has been started.
  Raises:
    socket.error: If a server could not be constructed with the host and port
      specified. Also logs an error message.
  """
  # Mute the werkzeug logging.
  base_logging.getLogger('werkzeug').setLevel(base_logging.WARNING)

  try:
    if host:
      # The user gave us an explicit host
      server = serving.make_server(host, port, tb_app, threaded=True)
      if ':' in host and not host.startswith('['):
        # Display IPv6 addresses as [::1]:80 rather than ::1:80
        final_host = '[{}]'.format(host)
      else:
        final_host = host
    else:
      # We've promised to bind to all interfaces on this host. However, we're
      # not sure whether that means IPv4 or IPv6 interfaces.
      try:
        # First try passing in a blank host (meaning all interfaces). This,
        # unfortunately, defaults to IPv4 even if no IPv4 interface is available
        # (yielding a socket.error).
        server = serving.make_server(host, port, tb_app, threaded=True)
      except socket.error:
        # If a blank host didn't work, we explicitly request IPv6 interfaces.
        server = serving.make_server('::', port, tb_app, threaded=True)
      final_host = socket.gethostname()
    server.daemon_threads = True
  except socket.error as socket_error:
    if port == 0:
      msg = 'TensorBoard unable to find any open port'
    else:
      msg = (
          'TensorBoard attempted to bind to port %d, but it was already in use'
          % FLAGS.port)
    logging.error(msg)
    print(msg)
    raise socket_error

  final_port = server.socket.getsockname()[1]
  tensorboard_url = 'http://%s:%d' % (final_host, final_port)
  return server, tensorboard_url

  def run(self):
    """Run the WSGI server in a thread."""
    logging.info("Listening on port %d.", self.port)

    ssl_context = None
    if config.CONFIG["AdminUI.enable_ssl"]:
      cert_file = config.CONFIG["AdminUI.ssl_cert_file"]
      if not cert_file:
        raise ValueError("Need a valid cert file to enable SSL.")

      key_file = config.CONFIG["AdminUI.ssl_key_file"]
      if not key_file:
        raise ValueError("Need a valid key file to enable SSL.")

      ssl_context = (cert_file, key_file)

    # Werkzeug only handles IPv6 if ":" is in the host (i.e. we pass
    # an IPv6 ip).
    ip = utils.ResolveHostnameToIP("localhost", self.port)
    server = serving.make_server(
        ip,
        self.port,
        wsgiapp.AdminUIApp().WSGIHandler(),
        ssl_context=ssl_context)

    # We want to notify other threads that we are now ready to serve right
    # before we enter the serving loop.
    self.ready_to_serve.set()
    while self.keep_running:
      server.handle_request()

    def _serve(self):
        # Load stored authentication keys
        self.keys = self.get_config_json("keys") or {}

        jsonify._instance = jsonify.GenericJSON(
            sort_keys=True,
            indent=4,
            separators=(',', ': '),
        )

        cert = self.get_config_json("cert") or '/etc/ceph/ceph-mgr-restful.crt'
        pkey = self.get_config_json("pkey") or '/etc/ceph/ceph-mgr-restful.key'

        # Create the HTTPS werkzeug server serving pecan app
        self.server = make_server(
            host='0.0.0.0',
            port=8003,
            app=make_app(
                root='restful.api.Root',
                hooks = lambda: [ErrorHook()],
            ),
            ssl_context=(cert, pkey),
        )

        self.server.serve_forever()

 def inner():
     # server = serving.make_server(host, app_port, self._app,
     #     False, 1, ClientCertHTTPRequestHandler, False,
     #     'adhoc')
     server = serving.make_server(
         host, app_port, self._app, False, 1,
         ClientCertHTTPRequestHandler, False,
         ssl_context=context)
     # server = serving.make_server(host, app_port, self._app,
     #     False, 1, ClientCertHTTPRequestHandler,
     #     False, ssl_context=(context_crt, context_key))
     # Following line is the reason why I copied all that code!
     if must_have_client_cert:
     #if must_have_client_cert or must_use_speaks_for:
         # FIXME: what works with webapp does not with CLI
         server.ssl_context.set_verify(
             SSL.VERIFY_PEER |
             SSL.VERIFY_FAIL_IF_NO_PEER_CERT |
             # Ignoring certs unless SSL.VERIFY_PEER is set
             SSL.VERIFY_CLIENT_ONCE,
             lambda a, b, c, d, e: True)
     else:
         server.ssl_context.set_verify(
             SSL.VERIFY_NONE,
             lambda a, b, c, d, e: True)
     # Before entering loop, start supplementary services
     for s in services:
         s.start()
     # That's it
     server.serve_forever()

 def inner():
     server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, 'adhoc')
     # The following line is the reason why I copied all that code!
     if must_have_client_cert:
         server.ssl_context.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, lambda a,b,c,d,e: True)
     # That's it
     server.serve_forever()

    def __init__(self, credential_store, port, region, profile_name=None,
                 kms_host=None, kms_port=None, s3_host=None, s3_port=None,
                 s3_secure=True, kms_secure=True, aws_access_key_id=None,
                 aws_secret_access_key=None):
        from werkzeug.serving import make_server

        super(Server, self).__init__()
        self.port = port

        if credential_store.startswith("s3://"):
            kms = boto.kms.connect_to_region(
                region, profile_name=profile_name, host=kms_host,
                port=kms_port, is_secure=kms_secure,
                aws_access_key_id=aws_access_key_id,
                aws_secret_access_key=aws_secret_access_key)
            kms.auth_region_name = region
            kms.auth_service_name = "kms"

            s3 = boto.s3.connect_to_region(
                region, profile_name=profile_name,
                calling_format=OrdinaryCallingFormat(), host=s3_host,
                port=s3_port, is_secure=s3_secure,
                aws_access_key_id=aws_access_key_id,
                aws_secret_access_key=aws_secret_access_key)

            self.read_credentials_from_s3(credential_store, kms, s3)
        else:
            self.read_credentials_from_file(credential_store)

        self.app = Flask("kdist.server")
        self.handler = Handler(self.app, region, keymap=self.credentials)
        self.handler.server = make_server(
            "", self.port, self.app, threaded=True)
        self.credentials = None
        return

def run_simple_server(tb_app):
  """Start serving TensorBoard, and print some messages to console."""
  # Mute the werkzeug logging.
  base_logging.getLogger('werkzeug').setLevel(base_logging.WARNING)

  try:
    server = serving.make_server(FLAGS.host, FLAGS.port, tb_app, threaded=True)
    server.daemon_threads = True
  except socket.error:
    if FLAGS.port == 0:
      msg = 'TensorBoard unable to find any open port'
    else:
      msg = (
          'TensorBoard attempted to bind to port %d, but it was already in use'
          % FLAGS.port)
    logging.error(msg)
    print(msg)
    exit(-1)

  port = server.socket.getsockname()[1]
  msg = 'Starting TensorBoard %s at http://%s:%d' % (tb_app.tag, FLAGS.host,
                                                     port)
  print(msg)
  logging.info(msg)
  print('(Press CTRL+C to quit)')
  sys.stdout.flush()

  server.serve_forever()

def startHelpServer(port=48626):
    import socket, threading
    from werkzeug import serving

    max_attempts = 20
    http = None

    server = None
    server_port = port
    for i in range(max_attempts):
        try:
            # TODO: Use host specified by .ini configuration.
            server = serving.make_server("0.0.0.0", server_port, app=bookish_app)
            break
        except socket.error:
            server_port += 1
            pass

    if not server:
        raise Exception("Could not find open port for help server.")

    serverthread = threading.Thread(target=server.serve_forever)
    serverthread.start()

    return server_port

def restart_with_reloader():
    to_mon = []
    while 1:
        _log('info', ' * Clastic restarting with reloader')
        args = [sys.executable] + sys.argv
        new_environ = os.environ.copy()
        new_environ['WERKZEUG_RUN_MAIN'] = 'true'
        if os.name == 'nt':
            for key, value in new_environ.iteritems():
                if isinstance(value, unicode):
                    new_environ[key] = value.encode('iso-8859-1')
        stderr_buff = []
        child_proc = subprocess.Popen(args, env=new_environ, stderr=subprocess.PIPE)
        rf = child_proc.stderr
        exit_code, lines = None, []
        while exit_code is None or lines:
            if child_proc.poll() is None:
                lines.append(rf.readline())
            elif exit_code is None:
                lines.extend(rf.readlines())
                exit_code = child_proc.returncode
                if not lines:
                    break
            cur_line = lines.pop(0)
            if cur_line.startswith(_MON_PREFIX):
                to_mon = literal_eval(cur_line[len(_MON_PREFIX):])
            else:
                sys.stderr.write(cur_line)
                stderr_buff.append(cur_line)
                if len(stderr_buff) > _STDERR_BUFF_SIZE:
                    stderr_buff.pop(0)

        if exit_code == 3:
            continue
        elif exit_code == 1 and stderr_buff:
            enable_tty_echo()
            from clastic import flaw
            tb_str = ''.join(stderr_buff)
            err_app = flaw.create_app(tb_str, to_mon)
            # TODO: these values should be passed through
            err_server = make_server('localhost', 5000, err_app)
            thread.start_new_thread(err_server.serve_forever, ())
            try:
                reloader_loop(to_mon, 1)
            except KeyboardInterrupt:
                return 0
            except SystemExit as se:
                if se.code == 3:
                    continue
                return se.code
            finally:
                err_server.shutdown()
                err_server.server_close()
            return 0
        else:
            return exit_code

 def __init__(self, app, host="", port=0, threaded=True, processes=1,
             request_handler=RequestHandler, passthrough_errors=False, ssl_context=None):
     """ Use ssl_context='adhoc' for an ad-hoc cert, a tuple for a (cerk, pkey) files
         
     
     """
     threading.Thread.__init__(self)
     self.daemon=True
     self.server = make_server(host, port, app, threaded=threaded, processes=processes,
         request_handler=request_handler, passthrough_errors=passthrough_errors, ssl_context=ssl_context)

def setUpPackage():
    create_temp_database()
    apply_migrations()

    server = make_server('0.0.0.0', 65432, app)
    thread = threading.Thread(target=server.serve_forever)
    thread.daemon = True
    thread.start()
    web_actors['server'] = server

    web_actors['browser'] = SingleVisitFirefoxDriver()

    def _serve(self):
        # Load stored authentication keys
        self.refresh_keys()

        jsonify._instance = jsonify.GenericJSON(
            sort_keys=True,
            indent=4,
            separators=(',', ': '),
        )

        server_addr = self.get_localized_config('server_addr', '::')
        if server_addr is None:
            raise RuntimeError('no server_addr configured; try "ceph config-key put mgr/restful/server_addr <ip>"')
        server_port = int(self.get_localized_config('server_port', '8003'))
        self.log.info('server_addr: %s server_port: %d',
                      server_addr, server_port)

        cert = self.get_localized_config("crt")
        if cert is not None:
            cert_tmp = tempfile.NamedTemporaryFile()
            cert_tmp.write(cert)
            cert_tmp.flush()
            cert_fname = cert_tmp.name
        else:
            cert_fname = self.get_localized_config('crt_file')

        pkey = self.get_localized_config("key")
        if pkey is not None:
            pkey_tmp = tempfile.NamedTemporaryFile()
            pkey_tmp.write(pkey)
            pkey_tmp.flush()
            pkey_fname = pkey_tmp.name
        else:
            pkey_fname = self.get_localized_config('key_file')

        if not cert_fname or not pkey_fname:
            raise RuntimeError('no certificate configured')
        if not os.path.isfile(cert_fname):
            raise RuntimeError('certificate %s does not exist' % cert_fname)
        if not os.path.isfile(pkey_fname):
            raise RuntimeError('private key %s does not exist' % pkey_fname)

        # Create the HTTPS werkzeug server serving pecan app
        self.server = make_server(
            host=server_addr,
            port=server_port,
            app=make_app(
                root='restful.api.Root',
                hooks = [ErrorHook()],  # use a callable if pecan >= 0.3.2
            ),
            ssl_context=(cert_fname, pkey_fname),
        )

        self.server.serve_forever()

 def inner():
     #server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, 'adhoc')
     server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, ssl_context=context)
     #server = serving.make_server(host, app_port, self._app, False, 1, ClientCertHTTPRequestHandler, False, ssl_context=(context_crt, context_key))
     # The following line is the reason why I copied all that code!
     if must_have_client_cert:
         # FIXME: what works with web app does not work with cli. Check this out
         server.ssl_context.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, lambda a,b,c,d,e: True)
     # before enter in the loop, start the supplementary services
     for s in services:
         s.start()
     # That's it
     server.serve_forever()

    def __init__(self, app, host=None, port=5869):
        super().__init__()

        @app.route('/ping', methods=['GET'])
        def ping():
            return Response(status=200)

        self.host = host or os.environ.get('POD_IP', '127.0.0.1')
        self.port = port
        self.app = app
        self.server = make_server(self.host, self.port, app)
        self.context = app.app_context()
        self.context.push()

def before_all(context):
    # Use dev server and request vs test_client to allow running against other environments
    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
    app.config['TESTING'] = True

    host = 'localhost'
    port = '5000'
    context.base_url = 'http://' + host + ':' + port

    context.server = make_server(host, port, app, threaded=True)

    context.thread = threading.Thread(target=context.server.serve_forever)
    context.thread.start()