def main(argv):
    datafiles = ''
    datanames = ''
    port = 8071
    try:
        opts, args = getopt.getopt(argv, "hp:f:d:", 
                ["port=", "datafiles=", "datanames="])
    except getopt.GetoptError:
        print 'search.py -p <port> -d <datanames> -f <datafiles>'
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print 'search.py -p <port> -d <datanames> -f <datafiles>'
            sys.exit()
        elif opt in ("-d", "--datanames"):
            datanames = arg
        elif opt in ("-f", "--datafiles"):
            datafiles = arg
	elif opt in ("-p", "--port"):
	    port = arg

    init(datanames, datafiles)

    from wsgiref.simple_server import make_server
    try:
        print('Server started on port ' + str(port))
        make_server('', port, web).serve_forever()
    except KeyboardInterrupt:
        pass
    print('\nThanks!')

def command():
    parser = OptionParser(usage="%prog DIR [HOST][:][PORT]",
                          version="static 0.3.6")
    options, args = parser.parse_args()
    if len(args) in (1, 2):
        if len(args) == 2:
            parts = args[1].split(":")
            if len(parts) == 1:
                host = parts[0]
                port = None
            elif len(parts) == 2:
                host, port = parts
            else:
                sys.exit("Invalid host:port specification.")
        elif len(args) == 1:
            host, port = None, None
        if not host:
            host = '0.0.0.0'
        if not port:
            port = 9999
        try:
            port = int(port)
        except:
            sys.exit("Invalid host:port specification.")
        app = Cling(args[0])
        try:
            make_server(host, port, app).serve_forever()
        except KeyboardInterrupt:
            print("Cio, baby!")
        except:
            sys.exit("Problem initializing server.")
    else:
        parser.print_help(sys.stderr)
        sys.exit(1)

def main():
    logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)

    url_map = SessionMiddleware(urlmap, session_class=InMemorySession)

    print 'Serving on port: 8080'
    make_server('localhost', 8080, url_map).serve_forever()

def debugserver(host, port):
    """
    Run the webservice with the Python built-in HTTP server.
    """
    sys.stderr.write('Listening on http://%s:%d/\n' % (host, port))
    sys.stderr.write('WDSL file is at http://%s:%d/?wsdl\n' % (host, port))
    make_server(host, port, application).serve_forever()

  def StartWebServer(self, port, application=None):
    """Start web server.

    Args:
      port: Port to start application on.
      application: Optional WSGI function.  If none provided will use
        tests CreateWsgiApplication method.

    Returns:
      A tuple (server, application):
        server: An instance of ServerThread.
        application: Application that web server responds with.
    """
    if not application:
      application = self.CreateWsgiApplication()
    validated_application = validate.validator(application)

    try:
      server = simple_server.make_server(
          'localhost', port, validated_application)
    except socket.error:
      # Try IPv6
      server = simple_server.make_server(
          'localhost', port, validated_application, server_class=WSGIServerIPv6)

    server = ServerThread(server)
    server.start()
    return server, application

def run():
    here = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
    sys.path.insert(0, here)
    from fluxbin import app
    import controller

    simple_server.make_server("", 8080, app).serve_forever()

def main():

    # Command line options
    parser = ArgumentParser(prog='mrpypi')
    parser.add_argument('-p', dest='port', type=int, default=8080,
                        help='server port number (default is 8080)')
    parser.add_argument('--index', dest='index_url', default=DEFAULT_PIP_INDEX, metavar='URL',
                        help='upstream pypi index URL (default is "{0}")'.format(DEFAULT_PIP_INDEX))
    parser.add_argument('--no-index', dest='index_url', action='store_const', const=None,
                        help='disable upstream pypi index')
    parser.add_argument('--mongo', dest='mongo', action='store_true',
                        help='use MongoDB index')
    parser.add_argument('--mongo-uri', dest='mongo_uri', type=str, default=DEFAULT_MONGO_URI, metavar='URI',
                        help='MongoDB URI (default is "{0}")'.format(DEFAULT_MONGO_URI))
    args = parser.parse_args()

    # Create the index
    print('Upstream pypi index URL: {0}'.format(args.index_url))
    if args.mongo:
        print('Mongo index with URI: {0}'.format(args.mongo_uri))
        index = MongoIndex(index_url=args.index_url, mongo_uri=args.mongo_uri)
    else:
        print('Using memory index')
        index = MemoryIndex(index_url=args.index_url)

    # Start the application
    application = MrPyPi(index)
    print('Serving on port {0}...'.format(args.port))
    make_server('', args.port, application).serve_forever()

def _start_server(app, host, port):
    if pywsgi:
        logger.info("Server is running; using gevent server")
        pywsgi.WSGIServer((host, port), app).serve_forever()
    else:
        logger.info("Server is running; using wsgiref server")
        make_server(host, port, app).serve_forever()

    def run(self, runtime):
        from wsgiref.simple_server import make_server
        from mesh.transport.http import WsgiServer

        application = WsgiServer([self["bundle"]])
        hostname, port = self["hostname"].split(":")
        make_server(hostname, int(port), application).server_forever()

def main():
    cwd = os.getcwd()

    cfg = load_settings(cwd)

    handlers = []
    handlers.append(ConnectHandler(cfg))
    handlers.append(PermissionHandler(cfg))
    handlers.append(GrepHandler(cwd))
    handlers.append(FileListing(cwd, cfg))
    handlers.append(SaveHandler(cwd))
    handlers.append(ProjectFilesServer(cwd))
    handlers.append(NotFoundHandler())

    i = 0
    for handler in handlers:
        i += 1
        if i < len(handlers):
            handler.next_handler = handlers[i]

    try:
        print "Serving " + cwd + " to http://localhost:8888"
        make_server('localhost', 8888, handlers[0]).serve_forever()
    except KeyboardInterrupt, ki:
        print "\nBye bye"

def start_server(debug=False):
    message = 'Starting server at http://%s:%s' % (HOST, PORT)
    if debug:
        variables = settings.theme.get('vars', {})
        variables.update({'debug': True})
        settings.theme['vars'] = variables
    if RequestHandler is object:
        logging.info(message)
        make_server(HOST, int(PORT), wsgi_app).serve_forever()
    else:
        import tornado.web
        if g.output_directory == ROOT:
            #: if this is a liquidluck project, build the site
            load_posts(settings.config['source'])
            write_posts()
            logging.info('Theme directory: %s' % g.theme_directory)
        handlers = [
            (r'/livereload', LiveReloadHandler),
            (r'/livereload.js', LiveReloadJSHandler),
            (r'/theme/(.*)', ThemeStaticHandler),
            (r'(.*)', IndexHandler),
        ]
        app = tornado.web.Application(handlers=handlers, default_host=HOST)
        app.listen(int(PORT))
        logging.info(message)
        tornado.ioloop.IOLoop.instance().start()

def main():
    import wsgiref
    from wsgiref.simple_server import make_server
    from StringIO import StringIO

    if len(sys.argv)<2:
        print 'usage: frameless.py module_name [ip port]'
        return
    module_name = sys.argv[1]
    if len(sys.argv)>=4:
        ip = sys.argv[2]
        port = int(sys.argv[3])
    else:
        ip = 'localhost'
        port = 8000

    wsgi_app = functools.partial(app, module_name)

    '''
    test_env = {}
    wsgiref.util.setup_testing_defaults(test_env)
    test_env['QUERY_STRING'] = 'helloworld'
    test_env['wsgi.input'] = StringIO('xxx\nddd\nyyy\n')
    print wsgi_app(test_env, lambda a,b:None)
    '''

    print 'listening on %s:%d'%(ip, port)
    make_server(ip, port, wsgi_app).serve_forever()

def test():
    from wsgiref.validate import validator
    magics = StringMagic(title="String Test"), KidMagic(title="Kid Test")
    app = Shock('testdata/pub', magics=magics)
    try:
        make_server('localhost', 9999, validator(app)).serve_forever()
    except KeyboardInterrupt, ki:
        print "Ciao, baby!"

def run():
    host, port, directory = sys.argv[1:4]
    app = Cling(directory)
    try:
        from wsgiref.simple_server import make_server
        make_server(host, int(port), app).serve_forever()
    except KeyboardInterrupt:
        print("Cio, baby!")

 def serve(self, app=None):
     """Creates a http server"""
     if app is None:
         httpd = make_server('', 8000, self)
     else:
         httpd = make_server('', 8000, app)
     print "Webby: port 8000..."
     httpd.serve_forever()

 def make_server(self,serverIp='',port=8000,test=False):
     from wsgiref.simple_server import make_server
     from wsgiref.simple_server import 
     httpd = make_server(serverIp, port, self.make_app(), server_class=WSGIServer)  
     if test:
         httpd.handle_request()
     else:
         httpd.serve_forever()
     return True

 def get_new_token():
     authorize_url = client.authorization_url(
         client_id=CLIENT_ID,
         redirect_uri=('%s:%s' % (config.SERVER_HOST, CALLBACK_PORT))
     )
     webbrowser.open(authorize_url)
     print('Click here to authorize me to access your Strava activities: %s'
           % authorize_url)
     make_server('localhost', CALLBACK_PORT, auth_listener).handle_request()

def test():
    from wsgiref.validate import validator
    app = Cling(getcwd())
    try:
        print "Serving " + getcwd() + " to http://localhost:9999"
        make_server('localhost', 9999, validator(app)).serve_forever()
    except KeyboardInterrupt, ki:
        print ""
        print "Ciao, baby!"

 def run(self):
     while(1):
         #NOTE: we take no action if the local port is changed dynamically
         local_port = settings.get('local_port')
         if not local_port:
             time.sleep(1)
             continue
         logger.info("Starting web server at http://localhost:%d" % local_port)
         make_server('', local_port, self, handler_class=RCIWSGIRequestHandler).serve_forever()

def main(socketmodule=None):
    if socketmodule is None:
        socketmodule = socket

    app, port = get_args()

    if app == 'myapp':
        s = socketmodule.socket()
        host = socketmodule.getfqdn()
        if port == 0:
            port = random.randint(8000, 9999)
        s.bind((host, port))
        print 'Starting server on', host, port
        print 'The Web server URL for this would be http://%s:%d/' % (host, port)
        s.listen(5)
        print 'Entering infinite loop; hit CTRL-C to exit'
        while True:
            c, (client_host, client_port) = s.accept()
            print 'Got connection from', client_host, client_port
            handle_connection(c, client_port)

    elif app == 'image':
        imageapp.setup()
        p = imageapp.create_publisher()
        wsgi_app = quixote.get_wsgi_app()
        from wsgiref.simple_server import make_server
        host = socketmodule.getfqdn()
        if port == 0:
            port = random.randint(8000, 9999)
        httpd = make_server('', port, wsgi_app)
        print 'Starting server on', host, port
        print 'The Web server URL for this would be http://%s:%d/' % (host, port)
        try:
            httpd.serve_forever()
        finally:
            imageapp.teardown()

    elif app == 'altdemo':
        p = create_publisher()
        wsgi_app = quixote.get_wsgi_app()
        from wsgiref.simple_server import make_server
        host = socketmodule.getfqdn()
        if port == 0:
            port = random.randint(8000, 9999)
        p.is_thread_safe = True
        httpd = make_server('', port, wsgi_app)
        print 'Starting server on', host, port
        print 'The Web server URL for this would be http://%s:%d/' % (host, port)
        httpd.serve_forever()

    elif app in ('quotes', 'chat'):
        if port == 0:
            port = random.randint(8000, 9999)
        os.chdir(app)
        os.system("python2.7 %s-server %d" % (app, port))