Example #1
1
def run():
    config = ConfigParser.ConfigParser()
    config.read("config.ini")
    ws_port = config.get('port_config', 'ws_port')
    server = WSGIServer(("0.0.0.0", int(ws_port)), vity_ws, handler_class=WebSocketHandler,
            keyfile=config.get('ssl', 'keyfile'), certfile=config.get('ssl', 'certfile'))
    server.serve_forever()
Example #2
0
def main(port):
    ini_path = './production.ini'
    setup_logging(ini_path)
    app = get_app(ini_path, 'main')
    server = WSGIServer(('', port), app)
    server.backlog = 256
    server.serve_forever()
Example #3
0
def main():
    global ENVISALINKCLIENT

    parser = argparse.ArgumentParser('Flask powered Alarm Server')
    parser.add_argument('config', help='Configurationf file', default='')
    args = parser.parse_args()

    logger.info('Using configuration file %s' % args.config)

    config = AlarmServerConfig(args.config)

    # Create Envisalink client object
    ENVISALINKCLIENT = Envisalink.Client(config, CONNECTEDCLIENTS)
    gevent.spawn(ENVISALINKCLIENT.connect)

    app.debug = True
    server = WSGIServer(("", 5000), app, keyfile=config.KEYFILE, certfile=config.CERTFILE)

    gevent.spawn(publish)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print "Crtl+C pressed. Shutting down."
        logger.info('Shutting down from Ctrl+C')

        server.stop()
        raise SystemExit
Example #4
0
def web_main():

    log = logging.getLogger('web')

    def server_factory(global_conf, host, port):
        port = int(port)

        def serve(app):
            server = WSGIServer(('', port), app, )
            log.info('serving on port %s...', port)
            server.serve_forever()

        return serve

    port = 8000
    log.info('starting web server on port %s', port)

    config = Configurator(
        settings={
        'mako.directories': 'templates',
        'reload_templates': True
    })
    config.add_static_view('static', path='static')

    config.add_route('root', '/')
    config.add_route('logcat', '/logcat')

    config.scan()

    app = config.make_wsgi_app()

    http_server = WSGIServer(('', 8000), app, handler_class=WebSocketHandler)
    http_server.serve_forever()
Example #5
0
 def run(self, host, port, *args, **kw):
     from gevent.pywsgi import WSGIServer
     from gevent.monkey import patch_all; patch_all()
     logger = logging.getLogger('gevent')
     logger.info('Starting gevent on port: {}'.format(port))
     http_server = WSGIServer(('', port), self.manager.app)
     http_server.serve_forever()
Example #6
0
class Server(Greenlet):
    def __init__(self, name, addr, *args, **kwargs):
        Greenlet.__init__(self)
        self._application = Flask(name)
        self._server = WSGIServer(addr, self._application, *args, **kwargs)

        @self._application.errorhandler(404)
        def error_404(error):
            log.warning('web handler(%s) not found', request.path)
            return str(error), 404

        @self._application.errorhandler(Exception)
        def error_500(error):
            log.exception('web handler(%s) is error(%s)', request.path, error)
            return str(error), 500

    def _run(self):
        self._server.serve_forever()

    def close(self):
        self._server.stop()

    def getServer(self):
        return self._server

    def getApplication(self):
        return self._application

    def setHandler(self, handler, url=None, **kwargs):
        if not url:
            url = '/' + handler.__name__
        self._application.route(url, **kwargs)(handler)
Example #7
0
def main():
    options = parser.parse_args()

    logging.basicConfig(
        level=getattr(logging, options.log_level.upper(), logging.INFO),
        format="[%(asctime)s] %(filename)s:%(lineno)d %(levelname)s %(message)s"
    )

    app.config['DATABASE'] = options.db

    init_db()

    app.template_folder = TEMPLATES_PATH
    app.static_folder = STATIC_PATH

    log.info("Starting service on http://%s:%d/", options.listen, options.port)

    if options.debug:
        log.warning("Running on debug mode not for production.")
        app.run(host=options.listen, port=options.port, debug=True)
    else:
        http_server = WSGIServer((options.listen, options.port), app)

        with suppress(KeyboardInterrupt):
            http_server.serve_forever()
Example #8
0
def start_server(input_channels,
                 cors,
                 auth_token,
                 port,
                 initial_agent,
                 enable_api=True):
    """Run the agent."""

    if enable_api:
        app = server.create_app(initial_agent,
                                cors_origins=cors,
                                auth_token=auth_token)
    else:
        app = Flask(__name__)
        CORS(app, resources={r"/*": {"origins": cors or ""}})

    if input_channels:
        rasa_core.channels.channel.register(input_channels,
                                            app,
                                            initial_agent.handle_message,
                                            route="/webhooks/")

    if logger.isEnabledFor(logging.DEBUG):
        utils.list_routes(app)

    http_server = WSGIServer(('0.0.0.0', port), app)
    logger.info("Rasa Core server is up and running on "
                "{}".format(constants.DEFAULT_SERVER_URL))
    http_server.start()
    return http_server
Example #9
0
def _run():
    from gevent.pywsgi import WSGIServer
    server = WSGIServer(('127.0.0.1', 8999), app)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        server.stop()
Example #10
0
    def run(self, host='localhost', port=80):
        """Run the moulinette

        Start a server instance on the given port to serve moulinette
        actions.

        Keyword arguments:
            - host -- Server address to bind to
            - port -- Server port to bind to

        """
        try:
            if self.use_websocket:
                from gevent.pywsgi import WSGIServer
                from geventwebsocket.handler import WebSocketHandler

                server = WSGIServer((host, port), self._app,
                                    handler_class=WebSocketHandler)
                server.serve_forever()
            else:
                run(self._app, host=host, port=port)
        except IOError as e:
            if e.args[0] == errno.EADDRINUSE:
                raise MoulinetteError(errno.EADDRINUSE,
                                      m18n.g('server_already_running'))
            raise
Example #11
0
def run_server(instance_dir, address, port, access_log=False):

    # workaround on osx, disable kqueue
    if sys.platform == "darwin":
        os.environ['EVENT_NOKQUEUE'] = "1"

    sys.path.insert(0, instance_dir)

    os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'

    # This application object is used by any WSGI server configured to use this
    # file. This includes Django's development server, if the WSGI_APPLICATION
    # setting points here.
    from django.core.wsgi import get_wsgi_application
    application = get_wsgi_application()

    from gevent import monkey
    monkey.patch_all(dns=False)
    from gevent.pywsgi import WSGIServer

    if access_log:
        logfile = 'default'
    else:
        logfile = file(os.devnull, 'a+')

    server = WSGIServer((address, port), application, log=logfile)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        server.stop()
Example #12
0
    def go():

        app = get_app()
        app.debug = debug

        if app.debug:
            app.config.update(SEND_FILE_MAX_AGE_DEFAULT=0)

        #  TODO: asset debug settings will cause bad YSLOW rating
        app.config['COMPRESS_DEBUG'] = False
        app.config['ASSETS_DEBUG'] = debug

        # Breaks web socket communication
        # (WebSocketConnectionClosedException in client)
        # app = DebuggedApplication(app, evalex=True)

        host = conf_global['serverHost']
        port = conf_global['serverPort']
        print('Server: {0}:{1}'.format(host, port))
        http_server = WSGIServer((host, port),
                                 app,
                                 handler_class=WebSocketHandler)

        # gevent.spawn(send_dummy_notifications)
        gevent.spawn(send_bulk)

        http_server.serve_forever()
def start(host,port,allow_agent=False):
    import argparse
    from gevent.pywsgi import WSGIServer
    from geventwebsocket.handler import WebSocketHandler
    from jinja2 import FileSystemLoader
    import os

    root_path = os.path.dirname(wssh.__file__)
 #   root_path = '/home/bob/test/wssh/wssh'#os.path.dirname(wssh.__file__)
#    print "RootPath===>",root_path
    app.jinja_loader = FileSystemLoader(os.path.join(root_path, 'templates'))
    app.static_folder = os.path.join(root_path, 'static')


#    global wssh_server_log_file
    handler = RotatingFileHandler(wssh_server_log_file, maxBytes=10000000, backupCount=5)
    handler.setLevel(logging.DEBUG)
    app.logger.addHandler(handler)

    app.config['WSSH_ALLOW_SSH_AGENT'] = allow_agent

    agent = 'wsshd/{0}'.format(wssh.__version__)

    print '{0} running on {1}:{2}'.format(agent, host, port)

    app.debug = True
    http_server = WSGIServer((host, port), app,
        log=None,
        handler_class=WebSocketHandler)
    try:
        http_server.serve_forever()
    except KeyboardInterrupt:
        pass
Example #14
0
class WebServiceInterface(Interface):
    http_port = 80

    def __init__(self, *args, **kwargs):
        super(WebServiceInterface, self).__init__(*args, **kwargs)
        self.wsgi_server = None

    def on_start(self):
        super(WebServiceInterface, self).on_start()
        self.http_socket = create_socket('fd://%s' % self.container.get_shared_socket_fd(self.http_port))
        self.wsgi_server = WSGIServer(self.http_socket, Request.application(self.dispatch_request))
        self.wsgi_server.start()

    def on_stop(self):
        self.wsgi_server.stop()
        super(WebServiceInterface, self).on_stop()

    def dispatch_request(self, request):
        trace.set_id()
        urls = self.url_map.bind_to_environ(request.environ)
        request.urls = urls
        try:
            endpoint, args = urls.match()
            if callable(endpoint):
                handler = endpoint(self, request)
                response = handler.dispatch(args)
            else:
                try:
                    handler = getattr(self, endpoint)
                except AttributeError:
                    raise  # FIXME
                response = handler(request, **args)
        except HTTPException as e:
            response = e.get_response(request.environ)
        return response
Example #15
0
    def greenlet_admin(self):
        """ This greenlet is used to get status information about the worker when --admin_port was given
    """

        if self.config["processes"] > 1:
            self.log.debug("Admin server disabled because of multiple processes.")
            return

        from flask import Flask
        from mrq.dashboard.utils import jsonify

        app = Flask("admin")

        @app.route("/")
        def route_index():
            report = self.get_worker_report()
            report.update({"_id": self.id})
            return jsonify(report)

        self.log.debug("Starting admin server on port %s" % self.config["admin_port"])
        try:
            server = WSGIServer(("0.0.0.0", self.config["admin_port"]), app, log=open(os.devnull, "w"))
            server.serve_forever()
        except Exception, e:
            self.log.debug("Error in admin server : %s" % e)
Example #16
0
    def start_gevent(self):
        try:
            ssl_args = dict()
            certfile_path   = web.ub.config.get_config_certfile()
            keyfile_path    = web.ub.config.get_config_keyfile()
            if certfile_path and keyfile_path:
                if os.path.isfile(certfile_path) and os.path.isfile(keyfile_path):
                    ssl_args = {"certfile": certfile_path,
                                "keyfile": keyfile_path}
                else:
                    web.app.logger.info('The specified paths for the ssl certificate file and/or key file seem to be broken. Ignoring ssl. Cert path: %s | Key path: %s' % (certfile_path, keyfile_path))
            if os.name == 'nt':
                self.wsgiserver= WSGIServer(('0.0.0.0', web.ub.config.config_port), web.app, spawn=Pool(), **ssl_args)
            else:
                self.wsgiserver = WSGIServer(('', web.ub.config.config_port), web.app, spawn=Pool(), **ssl_args)
            web.py3_gevent_link = self.wsgiserver
            self.wsgiserver.serve_forever()

        except SocketError:
            try:
                web.app.logger.info('Unable to listen on \'\', trying on IPv4 only...')
                self.wsgiserver = WSGIServer(('0.0.0.0', web.ub.config.config_port), web.app, spawn=Pool(), **ssl_args)
                web.py3_gevent_link = self.wsgiserver
                self.wsgiserver.serve_forever()
            except (OSError, SocketError) as e:
                web.app.logger.info("Error starting server: %s" % e.strerror)
                print("Error starting server: %s" % e.strerror)
                web.helper.global_WorkerThread.stop()
                sys.exit(1)
        except Exception:
            web.app.logger.info("Unknown error while starting gevent")
Example #17
0
def main():
    status = 0
    parser = argparse.ArgumentParser()
    parser.add_argument('port', nargs='?', type=int, help='HTTP port', default=80)
    args = parser.parse_args()

    # start the dropbox service for handling file uploads
    dropbox.start()

    print 'starting web server on port %s' % args.port
    print 'press control-c to quit'
    try:
        server = WSGIServer(('0.0.0.0', args.port), api, handler_class=WebSocketHandler)
        log.info('entering main loop')
        server.serve_forever()
    except KeyboardInterrupt:
        dropbox.stop()
        log.info('exiting main loop')
    except Exception as e:
        str = 'could not start web server: %s' % e
        log.error(str)
        print str
        status = 1

    dropbox.stop()
    dropbox.join(60)

    log.info('exiting with status %d', status)
    return status
Example #18
0
def mmain():
	manager = multiprocessing.Manager()
	
	global PROCESSES
	PROCESSES = {}

	global PLUGINS
	PLUGINS = manager.list()	
	
	global CONTEXT
	CONTEXT = manager.dict()
	
	for plugin in os.listdir('plugins'):
		try:
			dir = os.path.join('plugins', plugin)
			if not os.path.isdir(dir):
				continue
			print 'Loading plugin {}'.format(plugin)
			p = Plugin(dir)
			PLUGINS.append(p)
			print 'Successfully loaded plugin: {}'.format(p)
		except Exception:
			traceback.print_exc(file=sys.stdout)
			print 'Failed to load plugin {}'.format(plugin)
	global http_server		
	http_server = WSGIServer(('',5000), app)
	#http_server.log = open('http.log', 'w')
	http_server.serve_forever()
Example #19
0
def run_server(options):
    api_listener = Api()
    gevent.spawn(api_listener.run)
    #
    # Setup flask app
    static_url_path = "/changed-so-it-doesnt-conflict-with-blueprint-static-path"
    app = Flask(__name__, static_url_path=static_url_path)
    app.config.from_pyfile(options["config"].name)
    app.register_blueprint(FrontendBlueprint())
    #
    # JS/CSS & HTML minification in production
    if not app.config.get('DEBUG'):
        from .misc.jinja2htmlcompress import HTMLCompress
        app.jinja_env.add_extension(HTMLCompress)
    assets = Environment()
    assets.init_app(app)
    #
    # Run server
    http = WSGIServer((options['http_host'], options['http_port']), app)
    LOGGER.info('Listening on %s:%s', options['http_host'], options['http_port'])
    try:
        http.serve_forever()
        return 0
    except KeyboardInterrupt:
        http.stop()
        api_listener.stop()
        LOGGER.info('Application Terminated')
        return 0
Example #20
0
    def start(self):
        '''Kickoff the TCP Server

        '''
        try:
            address = self.config.get('listener', 'ip')
            port = self.config.getint('listener', 'port')
            listener.server.listener.config_file = self.config_filename
            listener.server.listener.tail_method = listener.windowslogs.tail_method
            listener.server.listener.config['iconfig'] = self.config

            user_cert = self.config.get('listener', 'certificate')

            if user_cert == 'adhoc':
                basepath = self.determine_relative_filename('')
                cert, key = listener.certificate.create_self_signed_cert(basepath, 'ncpa.crt', 'ncpa.key')
            else:
                cert, key = user_cert.split(',')
            ssl_context = {'certfile': cert, 'keyfile': key}

            listener.server.listener.secret_key = os.urandom(24)
            http_server = WSGIServer(listener=(address, port),
                                     application=listener.server.listener,
                                     handler_class=webhandler.PatchedWSGIHandler,
                                     spawn=Pool(100),
                                     **ssl_context)
            http_server.serve_forever()
        except Exception, e:
            logging.exception(e)
Example #21
0
def run():
	from gevent.pywsgi import WSGIServer

	http_server = WSGIServer(('', app.config['HTTP_PORT']), app)
	if app.config['DEBUG']:
		debugModeStr = '''Debug mode enabled!'''
	else: 
		debugModeStr = ''
	try:
		print '''===========================================================================
   __...____________________          ,
   `(\ [ ===SPACEGDN===--|__|) ___..--"_`--.._____
     `"""""""""""""""""| |""` [_""_-___________"_/
                       | |   /..../`'-._.-'`
                   ____| |__/::..'_
                  |\ ".`"` '_____//\\
                  `"'-.   """""  \\\\/
                       `""""""""""`
===========================================================================
SpaceGDN developed by pyxld.com and is OSS under the MPL-2.0 at
https://github.com/connor4312/SpaceGDN. We're lifting off... 
===========================================================================
Running on '''+app.config['HTTP_HOST']+''':'''+str(app.config['HTTP_PORT'])+'''
'''+debugModeStr+'''
==========================================================================='''
		http_server.serve_forever()
	except KeyboardInterrupt:
		http_server.stop()
		print '''
Example #22
0
def main():
    handler = logging.FileHandler('server.log')
    handler.setLevel(logging.DEBUG)
    app.logger.setLevel(logging.DEBUG)
    app.logger.addHandler(handler)
    http_server = WSGIServer(('127.0.0.1', 8001), app)
    http_server.serve_forever()
Example #23
0
def main():
    parser, options, arguments = parse_options()
    if not arguments:
        parser.print_help()
        return
    
    # configure logging
    setup_logging(options.loglevel, options.logfile)
    
    proxy = TransparentProxy(arguments[0])
    throttler = WsgiThrottler(proxy, options.pool_size)
    
    # SSL settings
    if options.certfile and options.keyfile:
        ssl_settings = {"certfile": options.certfile, "keyfile": options.keyfile}
    else:
        ssl_settings = {}
    
    main_logger = getLogger(__name__)
    main_logger.info("Proxying %s on %s:%i with a maximum of %i concurrent requests" %(
        arguments[0],
        options.interface,
        options.port,
        options.pool_size,
    ))
    
    server = WSGIServer((options.interface, options.port), throttler, log=sys.stdout, **ssl_settings)
    server.serve_forever()
Example #24
0
def make_server(config, listener, app):
    """Make a Gevent server for WSGI apps."""
    max_concurrency = int(config.get("max_concurrency", 0)) or None
    stop_timeout = int(config.get("stop_timeout", 0))
    handler = config.get("handler", None)

    pool = Pool(size=max_concurrency)
    log = LoggingLogAdapter(logger, level=logging.DEBUG)

    kwargs = {}
    if gevent.version_info[:2] >= (1, 1):  # error_log is new in 1.1
        kwargs["error_log"] = LoggingLogAdapter(logger, level=logging.ERROR)

    if handler:
        kwargs["handler_class"] = _load_factory(handler, default_name=None)

    # pylint: disable=star-args
    server = WSGIServer(
        listener,
        application=app,
        spawn=pool,
        log=log,
        **kwargs
    )
    server.stop_timeout = stop_timeout
    return server
Example #25
0
def main():
    loglevel = 'INFO'

    datefmt = '%b %d %H:%M:%S'
    logformat = '%(asctime)s %(levelname)s pysms: %(message)s'

    logging.basicConfig(level=loglevel,
                        stream=sys.stdout,
                        format=logformat,
                        datefmt=datefmt)

    application = web.application(urls, globals()).wsgifunc()
    server = WSGIServer(('', 8088), application)

    signal(SIGTERM, exit, arping, server=server)
    signal(SIGQUIT, exit, arping, server=server)
    signal(SIGINT, exit, arping, server=server)

    print "Starting message dispatcher"
    dispatcher.start()
    print "Starting arping monitor"
    arping.start()
    print 'Serving on 8088...'
    server.start()

    while True:
        try:
            gevent.sleep(0)
        except KeyboardInterrupt:
            # Switch to main thread, to quit gracefully
            gevent.hub.get_hub().switch()
            exit(arping, server)
Example #26
0
 def start_http_server(self):
     try:
         sock = StreamServer.get_listener((SandeshHttp._HTTP_SERVER_IP,
             self._http_port), family=socket.AF_INET)
     except socket.error as e:
         self._logger.error('Unable to open HTTP Port %d, %s' %
             (self._http_port, e))
         sys.exit()
     else:
         self._http_port = sock.getsockname()[1]
         self._sandesh.record_port("http", self._http_port)
         self._logger.error('Starting Introspect on HTTP Port %d' %
             self._http_port)
         if self._sandesh_config and \
                 self._sandesh_config.introspect_ssl_enable:
             ca_certs=self._sandesh_config.ca_cert
             keyfile=self._sandesh_config.keyfile
             certfile=self._sandesh_config.certfile
             self._http_server = WSGIServer(sock, self._http_app,
                 ca_certs=ca_certs, keyfile=keyfile,
                 certfile=certfile, ssl_version=ssl.PROTOCOL_TLSv1,
                 cert_reqs=ssl.CERT_REQUIRED, log=self._std_log)
         else:
             self._http_server = WSGIServer(sock, self._http_app, log=self._std_log)
         self._http_server.serve_forever()
Example #27
0
def main():
    ip = config.listening_ip
    port = config.listening_port
    log.info("listening on %s:%d" % (ip, port))

    server = WSGIServer((ip, port), app,
                        handler_class=WebSocketHandler)
    server.serve_forever()
Example #28
0
File: start.py Project: zzmjohn/cdx
def start_app(app, verbose=False):
    global http_server
    if verbose:
        print "Starting server on port %d..." % cdx_app.port
    http_server = WSGIServer(('', cdx_app.port), app,
                             handler_class=WebSocketHandler,
                             )
    http_server.serve_forever()
Example #29
0
def runserver(port, ip, debug):

    if debug is None:
        server = WSGIServer((ip, port), app, handler_class=WebSocketHandler)
        server.serve_forever()

    click.echo(u"OpenMining start server at: {}:{}".format(ip, port))
    run(app=app, host=ip, port=port, debug=debug, reloader=True, server=GeventWebSocketServer)
Example #30
0
def start_app(verbose=False):
    global http_server
    if verbose:
        print "Starting server on port 5006..."
    http_server = WSGIServer(('', 5006), app,
                             handler_class=WebSocketHandler,
                             )
    http_server.serve_forever()
from __future__ import print_function
from gevent.pywsgi import WSGIServer


def application(env, start_response):

    if env['PATH_INFO'] == '/new_content':
        start_response('200 OK', [('Content-Type', 'application/json')])
        return [b'''ok''']
    else:
        start_response('404 Not Found', [('Content-Type', 'text/html')])
        return [b'<h1>Not Found</h1>']


if __name__ == '__main__':
    print('Serving on 8088...')
    WSGIServer(('', 8088), application).serve_forever()
Example #32
0
def startserver(adduser: Tuple, api: str, auth: bool, dburl: str,
                hydradoc: str, port: int, serverurl: str, token: bool,
                serve: None) -> None:
    """
    Python Hydrus CLI

    :param openapi:         : Sets the link to the Open Api Doc file.
    :param adduser <tuple>  : Contains the user credentials.
    :param api <str>        : Sets the API name for the server.
    :param auth <bool>      : Toggles the authentication.
    :param dburl <str>      : Sets the database URL.
    :param hydradoc <str>   : Sets the link to the HydraDoc file
                            (Supported formats - [.py, .jsonld, .yaml])
    :param port <int>       : Sets the API server port.
    :param serverurl <str>  : Sets the API server url.
    :param token <bool>     : Toggle token based user auth.
    :param serve            : Starts up the server.

    :return                 : None.


    Raises:
        Error: If `hydradoc` is not of a supported format[.py, .jsonld, .yaml].

    """
    # The database connection URL
    # See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html for more info
    # DB_URL = 'sqlite:///database.db'
    DB_URL = dburl

    # Define the server URL, this is what will be displayed on the Doc
    HYDRUS_SERVER_URL = "{}:{}/".format(serverurl, str(port))

    # The name of the API or the EntryPoint, the api will be at
    # http://localhost/<API_NAME>
    API_NAME = api

    click.echo("Setting up the database")
    # Create a connection to the database you want to use
    engine = create_engine(DB_URL)

    click.echo("Creating models")
    # Add the required Models to the database
    Base.metadata.create_all(engine)

    # Define the Hydra API Documentation
    # NOTE: You can use your own API Documentation and create a HydraDoc object
    # using doc_maker or you may create your own HydraDoc Documentation using
    # doc_writer [see hydra_python_core/doc_writer_sample]
    click.echo("Creating the API Documentation")

    if hydradoc:
        # Getting hydradoc format
        # Currently supported formats [.jsonld, .py, .yaml]
        try:
            hydradoc_format = hydradoc.split(".")[-1]
            if hydradoc_format == 'jsonld':
                with open(hydradoc, 'r') as f:
                    doc = json.load(f)
            elif hydradoc_format == 'py':
                doc = SourceFileLoader("doc",
                                       "./examples/drones/doc.py")\
                    .load_module().doc
            elif hydradoc_format == 'yaml':
                with open(hydradoc, 'r') as stream:
                    doc = parse(yaml.load(stream))
            else:
                raise("Error - hydradoc format not supported.")

            click.echo("Using %s as hydradoc" % hydradoc)
            apidoc = doc_maker.create_doc(doc,
                                          HYDRUS_SERVER_URL, API_NAME)

        except BaseException:
            click.echo("Problem parsing specified hydradoc file, "
                       "using sample hydradoc as default.")
            apidoc = doc_maker.create_doc(api_document,
                                          HYDRUS_SERVER_URL, API_NAME)
    else:
        click.echo("No hydradoc specified, using sample hydradoc as default.")
        apidoc = doc_maker.create_doc(api_document,
                                      HYDRUS_SERVER_URL, API_NAME)

    # Start a session with the DB and create all classes needed by the APIDoc
    session = scoped_session(sessionmaker(bind=engine))

    click.echo("Adding Classes and Properties")
    # Get all the classes from the doc
    # You can also pass dictionary defined in
    # hydra_python_core/doc_writer_sample_output.py
    classes = doc_parse.get_classes(apidoc.generate())

    # Get all the properties from the classes
    properties = doc_parse.get_all_properties(classes)

    # Insert them into the database
    doc_parse.insert_classes(classes, session)
    doc_parse.insert_properties(properties, session)

    click.echo("Adding authorized users")
    add_user(id_=adduser[0], paraphrase=adduser[1], session=session)

    # Insert them into the database
    doc_parse.insert_classes(classes, session)
    doc_parse.insert_properties(properties, session)

    click.echo("Creating the application")
    # Create a Hydrus app with the API name you want, default will be "api"
    app = app_factory(API_NAME)
    # Set the name of the API
    click.echo("Starting the application")
    with set_authentication(app, auth):
        # Use authentication for all requests
        with set_token(app, token):
            with set_api_name(app, api):
                # Set the API Documentation
                with set_doc(app, apidoc):
                    # Set HYDRUS_SERVER_URL
                    with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
                        # Set the Database session
                        with set_session(app, session):
                            # Start the Hydrus app
                            http_server = WSGIServer(('', port), app)
                            click.echo("Server running at:")
                            click.echo(
                                "{}{}".format(
                                    HYDRUS_SERVER_URL,
                                    API_NAME))
                            try:
                                http_server.serve_forever()
                            except KeyboardInterrupt:
                                pass
Example #33
0

@app.route('/test/', methods=['GET'])
def test():
    return 'hello test'


@app.route('/test/websocket/page/')
def test_websocket_page():
    return render_template('test_websocket.html')


@sockets.route('/test/websocket/')
def test_websocket(ws):
    data = None

    while not ws.closed:
        todo_list, count = get_todo_list()

        if not data == todo_list:
            data = todo_list
            send_data = {'data': data, 'count': count}

            ws.send(json.dumps(send_data))


if __name__ == "__main__":
    # app.run()
    http_server = WSGIServer(('', 5000), app, handler_class=WebSocketHandler)
    http_server.serve_forever()
Example #34
0
from gevent import monkey
monkey.patch_all()

import os
import sys
from scout.server import parse_options

# Create WSGI app using command-line options.
app = parse_options()

if __name__ == '__main__':
    # Serve app using gevent WSGI server.
    from gevent.pool import Pool
    from gevent.pywsgi import WSGIServer

    MAX_CONNECTIONS = int(os.environ.get('SCOUT_MAX_CONNECTIONS') or 128)
    pool = Pool(MAX_CONNECTIONS)
    try:
        (WSGIServer((app.config['HOST'], app.config['PORT']), app,
                    spawn=pool).serve_forever())
    except KeyboardInterrupt:
        app.logger.info('Shutting down!')
        sys.exit(0)
Example #35
0
    client = MongoClient(dburl)

    db = client.get_default_database()

    members = db.members

    data = []

    for mem in members.find():
        data.append(mem)

    data = sorted(data, key=lambda k: k['totalCommits'])

    return data[::-1]


app = Flask(__name__, static_url_path='/static')


@app.route("/")
def index():
    content = getContent()
    total = sum([x['totalCommits'] for x in content])
    return render_template('index.html', context=content, totalC=total)


if __name__ == '__main__':
    port = int(os.environ.get('PORT', 5000))
    http_server = WSGIServer(('', port), app)
    http_server.serve_forever()
Example #36
0
def main():
    http_server = WSGIServer(('0.0.0.0', 5000), app)
    print("Serving at 0.0.0.0:5000")
    http_server.serve_forever()
Example #37
0
def _run_gevent(app, config, mode):
    """Run WsgiDAV using gevent if gevent is installed.

    See
      https://github.com/gevent/gevent/blob/master/src/gevent/pywsgi.py#L1356
      https://github.com/gevent/gevent/blob/master/src/gevent/server.py#L38
     for more options
    """
    import gevent
    import gevent.monkey

    gevent.monkey.patch_all()
    from gevent.pywsgi import WSGIServer

    server_args = {
        "bind_addr": (config["host"], config["port"]),
        "wsgi_app": app
    }

    server_name = "WsgiDAV/{} gevent/{} Python/{}".format(
        __version__, gevent.__version__, util.PYTHON_VERSION)

    # Support SSL
    ssl_certificate = _get_checked_path(config.get("ssl_certificate"), config)
    ssl_private_key = _get_checked_path(config.get("ssl_private_key"), config)
    ssl_certificate_chain = _get_checked_path(
        config.get("ssl_certificate_chain"), config)

    # Override or add custom args
    server_args.update(config.get("server_args", {}))

    protocol = "http"
    if ssl_certificate:
        assert ssl_private_key
        protocol = "https"
        _logger.info("SSL / HTTPS enabled.")
        dav_server = WSGIServer(
            server_args["bind_addr"],
            app,
            keyfile=ssl_private_key,
            certfile=ssl_certificate,
            ca_certs=ssl_certificate_chain,
        )

    else:
        dav_server = WSGIServer(server_args["bind_addr"], app)

    # If the caller passed a startup event, monkey patch the server to set it
    # when the request handler loop is entered
    startup_event = config.get("startup_event")
    if startup_event:

        def _patched_start():
            dav_server.start_accepting = org_start  # undo the monkey patch
            org_start()
            _logger.info("gevent is ready")
            startup_event.set()

        org_start = dav_server.start_accepting
        dav_server.start_accepting = _patched_start

    _logger.info("Running {}".format(server_name))
    _logger.info("Serving on {}://{}:{} ...".format(protocol, config["host"],
                                                    config["port"]))
    try:
        gevent.spawn(dav_server.serve_forever())
    except KeyboardInterrupt:
        _logger.warning("Caught Ctrl-C, shutting down...")
    return
Example #38
0
        response = None
        while attempts:
            try:
                response = requests.get(url, timeout=2)
            except requests.ReadTimeout:
                attempts -= 1
                continue
            try:
                json.loads(response.content)
                break
            except ValueError:
                attempts -= 1

        _touch_empty_file(path, query_string, content, headers)
        if response:
            headers = {}
            headers['Content-Type'] = response.headers['content-type']
            _save_content_and_headers(path, query_string, response.content, headers)
            content = add_translations(response.content, lang)
        else:
            content = "{}"

    return content, 200, headers

if __name__ == "__main__":
    #app.run(host='0.0.0.0', port=5001, debug=False)
    #app.debug = True
    bind_addr = "0.0.0.0"
    SERVER = WSGIServer((bind_addr, PROXY_PORT), APP)
    SERVER.serve_forever()
Example #39
0
 def run(self):
     http_server = WSGIServer(('0.0.0.0', 8080), app)
     http_server.serve_forever()
Example #40
0
    active_room.subscribe(user)
    print('subscribe', active_room, user)

    messages = active_room.backlog()

    return render_template('room.html', room=room, uid=uid, messages=messages)


@app.route("/put/<room>/<uid>", methods=["POST"])
def put(room, uid):
    user = users[uid]
    room = rooms[room]

    message = request.form['message']
    room.add(':'.join([uid, message]))

    return ''


@app.route("/poll/<uid>", methods=["POST"])
def poll(uid):
    try:
        msg = users[uid].queue.get(timeout=10)
    except queue.Empty:
        msg = []
    return json.dumps(msg)


if __name__ == "__main__":
    http = WSGIServer(('', 5000), app)
    http.serve_forever()
Example #41
0
    if topic is None:
        topic = ":firstpage"

    if topic.startswith(':shell-x/'):
        return _proxy()
        #return requests.get('http://127.0.0.1:3000'+topic[8:]).text

    ip_address = get_request_ip(request)
    if '+' in topic:
        not_allowed = LIMITS.check_ip(ip_address)
        if not_allowed:
            return "429 %s\n" % not_allowed, 429

    html_is_needed = is_html_needed(
        user_agent) and not is_result_a_script(topic)
    result, found = cheat_wrapper(topic,
                                  request_options=options,
                                  html=html_is_needed)
    if 'Please come back in several hours' in result and html_is_needed:
        return MALFORMED_RESPONSE_HTML_PAGE

    log_query(ip_address, found, topic, user_agent)
    if html_is_needed:
        return result
    return Response(result, mimetype='text/plain')


SRV = WSGIServer((SERVER_ADDRESS, SERVER_PORT), app)  # log=None)
SRV.serve_forever()
Example #42
0
from gevent.pywsgi import WSGIServer
from flask_app.app import app

# As flask is not a production suitable server, we use will
# a WSGIServer instance to serve our flask application.
if __name__ == '__main__':
    WSGIServer(('0.0.0.0', 8000), app).serve_forever()
Example #43
0
  finally:
    if config.chmod():
      os.chmod(filename, config.chmod())
    os.chown(filename, config.owner_id(), config.group_id())
    print >> sys.stderr, 'Closing websocket'
    wsock.close()
  end_time = time.time()
  print >> sys.stderr, 'Took %.3f seconds' % (end_time - start_time)
  with open(filename, 'rb') as f:
    print >> sys.stderr, hashlib.md5(f.read()).hexdigest()

@app.error(404)
def error404(error):
  return '<h1>404 Error</h1>'


# Monkey patch geventwebsocket.websocket.Header.mask_payload() and
# geventwebsocket.websocket.Header.unmask_payload(), for efficiency
Header.mask_payload = util.mask_payload_fast
Header.unmask_payload = util.mask_payload_fast

if __name__ == '__main__':
  if len(sys.argv) == 3:
    hostname = sys.argv[1]
    port = int(sys.argv[2])
  else:
    hostname, port = ('localhost', 8080)
  server = WSGIServer((hostname, port), app, handler_class=util.UploadHandler)
  print >> sys.stderr, 'Listening on %s:%d' % (hostname, port)
  server.serve_forever()
Example #44
0
    def run(self):

        # Set absolute plugin path
        plugins_abs = os.path.abspath(os.path.join(filename.get_dirname_file(), self.config_parser.get(u'plugin directives', u'plugin_path')))
        self.config_parser.set(u'plugin directives', u'plugin_path', plugins_abs)

        # Check if there is a start delay
        try:
            delay_start = self.config_parser.get('listener', 'delay_start')
            if delay_start:
                logging.info('Delayed start in configuration. Waiting %s seconds to start.', delay_start)
                time.sleep(int(delay_start))
        except Exception:
            pass

        # Handle DB maintenance
        self.db.run_db_maintenance(self.config_parser)

        try:
            try:
                address = self.config_parser.get('listener', 'ip')
            except Exception:
                self.config_parser.set('listener', 'ip', '::')
                address = '::'

            try:
                port = self.config_parser.getint('listener', 'port')
            except Exception:
                self.config_parser.set('listener', 'port', 5693)
                port = 5693

            listener.server.listener.config['iconfig'] = self.config_parser

            user_cert = self.config_parser.get('listener', 'certificate')
            ssl_str_version = self.config_parser.get('listener', 'ssl_version')

            try:
                ssl_str_ciphers = self.config_parser.get('listener', 'ssl_ciphers')
            except Exception:
                ssl_str_ciphers = None

            try:
                ssl_version = getattr(ssl, 'PROTOCOL_' + ssl_str_version)
            except:
                ssl_version = getattr(ssl, 'PROTOCOL_TLSv1')
                ssl_str_version = 'TLSv1'
            logging.info('Using SSL version %s', ssl_str_version)

            if user_cert == 'adhoc':
                basepath = filename.get_dirname_file()
                certpath = os.path.abspath(os.path.join(basepath, 'var'))
                cert, key = listener.certificate.create_self_signed_cert(certpath, 'ncpa.crt', 'ncpa.key')
            else:
                cert, key = user_cert.split(',')

            # Create SSL context that will be passed to the server
            ssl_context = {
                'certfile': cert,
                'keyfile': key,
                'ssl_version': ssl_version
            }

            # Add SSL cipher list if one is given
            if ssl_str_ciphers:
                ssl_context['ciphers'] = ssl_str_ciphers

            listener.server.listener.secret_key = os.urandom(24)
            http_server = WSGIServer(listener=(address, port),
                                     application=listener.server.listener,
                                     handler_class=WebSocketHandler,
                                     spawn=Pool(200),
                                     **ssl_context)
            http_server.serve_forever()
        except Exception, e:
            logging.exception(e)
Example #45
0
class SandeshHttp(object):

    _HTTP_SERVER_IP = '0.0.0.0'
    _http_response = None
    _http_response_context = None
    _logger = None

    WebFilesList = [
        '/css/bootstrap.min.css', '/css/DT_bootstrap.css',
        '/css/images/sort_asc.png', '/css/images/sort_asc_disabled.png',
        '/css/images/sort_both.png', '/css/images/sort_desc.png',
        '/css/images/sort_desc_disabled.png', '/css/style.css',
        '/js/bootstrap.min.js', '/js/DT_bootstrap.js',
        '/js/jquery-2.0.3.min.js', '/js/jquery.dataTables.min.js',
        '/js/util.js', '/universal_parse.xsl'
    ]

    def __init__(self, sandesh, module, port, pkg_list):
        self._sandesh = sandesh
        self._logger = sandesh.logger()
        self._module = module
        self._http_port = port
        self._http_request_dict = {}
        self._http_app = bottle.Bottle()
        self._create_homepage(pkg_list)
        # Register the homepage
        self._http_app.route('/', 'GET', self._get_homepage)
        self._http_app.route('/index.html', 'GET', self._get_homepage)
        self._http_app.route('/<link:re:\w+.xml>', 'GET', self._get_indexpage)
        # Get the path of universal_parse.xsl and jquery and register the same
        self._webfiles_path = None
        self._universal_parse_xsl_path = None
        self._jquery_collapse_storage_js_path = None
        self._jquery_collapse_js_path = None
        self._jquery_1_8_1_js_path = None
        self._http_server = None
        try:
            imp_pysandesh = __import__('pysandesh')
        except ImportError:
            self._logger.error('Failed to import "pysandesh"')
        else:
            self._webfiles_path = imp_pysandesh.__path__[0]
            self._universal_parse_xsl_path = imp_pysandesh.__path__[0]
            self._jquery_collapse_storage_js_path = imp_pysandesh.__path__[0]
            self._jquery_collapse_js_path = imp_pysandesh.__path__[0]
            self._jquery_1_8_1_js_path = imp_pysandesh.__path__[0]

        for elem in SandeshHttp.WebFilesList:
            #import pdb; pdb.set_trace()
            self._http_app.route(elem, 'GET', self._get_webfiles)

    #end __init__

    def stop_http_server(self):
        if self._http_server:
            self._http_server.stop()
            self._http_server = None
            self._logger.error('Stopped http server')

    # end stop_http_server

    def start_http_server(self):
        try:
            sock = StreamServer.get_listener(
                (SandeshHttp._HTTP_SERVER_IP, self._http_port),
                family=socket.AF_INET)
        except socket.error as e:
            self._logger.error('Unable to open HTTP Port %d, %s' %
                               (self._http_port, e))
            sys.exit()
        else:
            self._http_port = sock.getsockname()[1]
            self._sandesh.record_port("http", self._http_port)
            self._logger.error('Starting Introspect on HTTP Port %d' %
                               self._http_port)
            self._http_server = WSGIServer(sock, self._http_app)
            self._http_server.serve_forever()

    # end start_http_server

    def get_port(self):
        return self._http_port

    #end get_port

    @staticmethod
    def http_error(err_msg):
        return '<h3>%s</h3>' % (err_msg)

    #end http_error

    @staticmethod
    def create_http_response(sandesh_resp, sandesh_init):
        universal_xsl_str = '<?xml-stylesheet type="text/xsl" href="/universal_parse.xsl"?>'
        transport = TTransport.TMemoryBuffer()
        protocol_factory = TXMLProtocol.TXMLProtocolFactory()
        protocol = protocol_factory.getProtocol(transport)
        if sandesh_resp.write(protocol) < 0:
            sandesh_init.logger().error(
                'Http Response: Failed to encode sandesh (%s)',
                sandesh_resp.__class__.__name__)
            return
        sandesh_resp_xml = transport.getvalue()
        if not SandeshHttp._http_response:
            SandeshHttp._state = 'HXMLNew'
            SandeshHttp._http_response = cStringIO.StringIO()
            SandeshHttp._http_response.write(universal_xsl_str)
            if sandesh_resp._more:
                sandesh_name_end = sandesh_resp_xml.find(' ')
                if sandesh_name_end == -1:
                    sandesh_init.logger().error(
                        'Http Response: Failed to get Sandesh name (%s)',
                        sandesh_resp.__class__.__name__)
                    return
                SandeshHttp._http_response_context = sandesh_resp_xml[
                    1:sandesh_name_end]
                SandeshHttp._http_response.write(
                    '<__%s_list type="slist">' %
                    (SandeshHttp._http_response_context))
                SandeshHttp._state = 'HXMLIncomplete'
        SandeshHttp._http_response.write(sandesh_resp_xml)
        if not sandesh_resp._more and SandeshHttp._state != 'HXMLNew':
            SandeshHttp._http_response.write(
                '</__%s_list>' % (SandeshHttp._http_response_context))

    #end create_http_response

    @staticmethod
    def get_http_response():
        if SandeshHttp._http_response:
            bottle.response.headers['Content-Type'] = 'text/xsl'
            resp = SandeshHttp._http_response.getvalue()
            SandeshHttp._http_response.close()
            SandeshHttp._http_response = None
            SandeshHttp._http_response_context = None
            return resp
        return None

    #end get_http_response

    def _get_homepage(self):
        bottle.response.headers['Content-Type'] = 'text/html'
        return self._homepage

    #end _get_homepage

    def _get_indexpage(self, link):
        try:
            path = self._homepage_links[link]
        except KeyError:
            return self.http_error('Invalid Sandesh Request "%s"' % (link))
        else:
            return bottle.static_file(link, root=path)

    #end _get_indexpage

    def _get_webfiles(self):
        terms = bottle.request.url.rsplit('/', 1)
        fname = "/" + terms[1]
        upath = terms[0].split('//', 1)[-1]
        pterms = upath.split('/', 1)
        if len(pterms) == 1:
            fpath = self._webfiles_path + '/webs'
        else:
            fpath = self._webfiles_path + '/webs/' + pterms[1]
        #import pdb; pdb.set_trace()
        return bottle.static_file(fname, root=fpath)

    #end _get_webfiles

    def _create_homepage(self, pkg_list):
        self._homepage_links = {}
        for pkg_name in pkg_list:
            self._extract_http_requests(pkg_name)
        homepage_str = cStringIO.StringIO()

        homepage_str.write(
            "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"" +
            " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
            "<html xmlns=\"http://www.w3.org/1999/xhtml\">" + "<head>" +
            "<link href=\"css/style.css\" rel=\"stylesheet\" type=\"text/css\"/>"
            + ("<title>%s</title></head><body>" % self._module))

        homepage_str.write('<h1>Modules for %s</h1>' % (self._module))
        for link in self._homepage_links.iterkeys():
            http_link = '<a href="%s">%s</a><br/>' % (link,
                                                      link[:link.find('.')])
            homepage_str.write(http_link)
        self._homepage = homepage_str.getvalue()
        homepage_str.close()

    #end _create_homepage

    def _extract_http_requests(self, package):
        try:
            imp_pkg = __import__(package)
        except ImportError:
            self._logger.error('Failed to import package "%s"' % (package))
        else:
            try:
                pkg_path = imp_pkg.__path__
            except AttributeError:
                self._logger.error('Failed to get package [%s] path' %
                                   (package))
                return
            for importer, mod, ispkg in \
                pkgutil.walk_packages(path=pkg_path, prefix=imp_pkg.__name__+'.'):
                if not ispkg:
                    if 'http_request' == mod.rsplit('.', 1)[-1]:
                        self._add_http_request_links(pkg_path[0], mod)

    #end _extract_http_requests

    def _add_http_request_links(self, pkg_path, mod):
        try:
            http_module = importlib.import_module(mod)
        except ImportError:
            self._logger.error('Failed to import Module "%s"' % (mod))
        else:
            try:
                http_req_list = getattr(http_module, '_HTTP_REQUEST_LIST')
            except AttributeError:
                self._logger.error(
                    '"%s" module does not have http request list' % (mod))
            else:
                # Add the link to the homepage, only if the request list is non-empty
                if len(http_req_list):
                    pkg = mod.rsplit('.', 1)[0]
                    link = pkg.rsplit('.', 1)[-1] + '.xml'
                    sub_path = pkg.split('.', 1)[-1].replace('.', '/')
                    path = pkg_path + '/' + sub_path
                    self._logger.debug('Add [%s:%s] to home page' %
                                       (link, path))
                    # TODO: Check for the existence of the html file
                    self._homepage_links[link] = path
                    self._register_http_requests(http_req_list)

    #end _add_http_request_links

    def _register_http_requests(self, http_req_list):
        for req in http_req_list:
            self._logger.debug('Add http request [%s]' % (req['uri']))
            self._http_request_dict[req['uri']] = req['method']
            self._http_app.route(req['uri'], 'GET', self._http_handle_request)

    #end _register_http_requests

    def _http_handle_request(self):
        # Call the handler
        method = self._http_request_dict[bottle.request.path]
        return method(self._sandesh)
Example #46
0
import os

import leancloud
from gevent.pywsgi import WSGIServer
from geventwebsocket.handler import WebSocketHandler

from app import app
from cloud import Engine
from leancloud import HttpsRedirectMiddleware

monkey.patch_all()

APP_ID = os.environ['LC_APP_ID']
MASTER_KEY = os.environ['LC_APP_MASTER_KEY']
PORT = int(os.environ['LC_APP_PORT'])

leancloud.init(APP_ID, master_key=MASTER_KEY)

# app 为您的 wsgi 函数
app = HttpsRedirectMiddleware(app)
engine = Engine(app)
application = engine

if __name__ == '__main__':
    # 只在本地开发环境执行的代码
    app.debug = True
    server = WSGIServer(('localhost', PORT),
                        application,
                        handler_class=WebSocketHandler)
    server.serve_forever()
Example #47
0
from gevent.pywsgi import WSGIServer

from bottle import Bottle, request

app = Bottle()


@app.post('/callback/')
def callback():
    data = request.body.read()
    data = json.loads(data)
    print data
    now = int(time.time())
    text = "time diff = {0}\n".format(now - data['start'] - data['seconds'])

    with open('callback.log', 'a') as f:
        f.write(text)

    return {'ret': 0}
    # return {
    #     'ret': 0,
    #     'data': {
    #             'callback_cmd': 'http://127.0.0.1:8000/callback/',
    #             'callback_data': json.dumps({'start': now, 'seconds': 2}),
    #             'seconds': 2,
    #         }
    # }


WSGIServer(('127.0.0.1', 8000), app).serve_forever()
Example #48
0
class OctoFlowStatus():
    def __init__(self):
        self.listener = _tcp_listener(('0.0.0.0', wsport), reuse_addr=1)
        self.access_log = access_log
        self.error_log = errors_log
        self.ipaddress = ipaddress
        self.client_address = None
        self.client_raddress = None
        self.pprocess_id = os.getpid()  # parent pid
        self.process_id = None
        self.request_line = None
        self.http_user_agent = None
        self.http_host = None
        self.status = None
        self.real_ip = None
        self.file_size = None
        self.time_start = timeit.default_timer()
        self.time_finish = 0
        self.server = None
        self.serverName = "OctoFlowStatus"
        self.redisPool = redis.ConnectionPool(host=config.redisServer,
                                              port=config.redisPort,
                                              db=config.redisDB)
        self.redis = redis.Redis(connection_pool=self.redisPool)
        self.redisSub = self.redis.pubsub()
        self.redisPSName = config.pubsubName
        self.mqServer = config.mqServer
        self.mqAuth = config.mqAuth
        self.session_name = config.sessionName
        self.session_domain = config.sessionDomain
        self.session_id = ""
        self.session_key = ""
        self.session_val = ""
        self.headers = ""
        self.session_expires = config.sessionExpires
        self.session_info = {}
        self.hostname = hostname
        self.request_method = ""
        self.environ = ""
        self.memdb = ""

        self.config = config
        self.txid = None
        self.__stop = False

        self.logger1 = OctoflowLogger('octoFlowRest1')
        self.logger2 = OctoflowLogger('octoFlowRest2')

        self.infoFile = '{0}/{1}-{2}.log'.format(config.statLogDir,
                                                 config.statLogLevel.lower(),
                                                 self.hostname)
        self.errorFile = '{0}/error-{1}.log'.format(config.statLogDir,
                                                    self.hostname)

        #self.logger1.streamHandler(config.restLogLevel)
        self.log_info = self.logger1.timeRotateHandler(
            filename=self.infoFile,
            when="m",
            interval=60,
            backupCount=0,
            level=config.restLogLevel)

        #self.logger2.streamHandler("ERROR")
        self.log_error = self.logger2.timeRotateHandler(
            filename=self.errorFile,
            when="m",
            interval=60,
            backupCount=0,
            level="ERROR")
        self.adminQueue = config.adminQueue

        self.database = cmysql.DataBase()

        #self.recvConnection	= pika.BlockingConnection( pika.URLParameters(self.mqServer) )

    def stop(self, signum, frame):
        self.__stop = True

    def sessionCache(self, rtype, key, val="", timeout=""):
        if rtype == 'set':
            if timeout != "":
                self.redis.set(key, val, timeout)
            else:
                self.redis.set(key, val)
        elif rtype == 'get':
            try:
                return self.redis.get(key)
            except:
                return None

    def logWrite(self, data):
        self._redisPublish(data)

    def _redisPublish(self, data):
        excTime = round(timeit.default_timer() - self.time_start, 6)
        if self.real_ip and self.client_address:
            client_address = '%s => %s' % (self.real_ip, self.client_address)
        else:
            client_address = "localhost"

        logform = "[{0}] [{1}] [{2}] [{3}] [{4}] [{5}] [{6}] [{7}] [{8}]".format(
            self.txid,
            datetime.now(),
            self.hostname,
            self.ipaddress,
            self.pprocess_id,
            self.process_id,
            client_address,
            excTime,
            data,
        )
        self.redis.publish(self.redisPSName, logform)

    def errorLog(self, funcName, e, data):
        self.error_log.write(
            '[{0}] [{1}] [{2}] [{3}] [{4}] [{5}] [{6}] [{7}]\n {8}\n\n'.format(
                self.txid, datetime.now(), self.hostname, self.ipaddress,
                self.pprocess_id, self.process_id, funcName, str(e), data))

    def _clientAddress(self, environ):
        try:
            self.real_ip = environ['HTTP_X_FORWARDED_FOR']
        except Exception as e:
            #self.errorLog( '_clientAddress', e, traceback.format_exc() )
            self.real_ip = environ['REMOTE_ADDR']
        self.client_address = environ['REMOTE_ADDR']

        self.client_raddress = '%s' % (self.client_address)
        if self.real_ip:
            self.client_raddress = '%s => %s' % (self.real_ip,
                                                 self.client_address)

    def format_request(self):
        delta = self.time_finish - self.time_start
        return '[%s] [%s] [%s] [%s] [%s] [%s] [%s] [%.6f] "%s" "%s" %s %s %s' % (
            self.txid, datetime.now(), self.hostname, self.ipaddress,
            self.pprocess_id, os.getpid(), self.client_raddress, delta,
            self.request_line or '', self.http_user_agent, self.http_host,
            (self.status or '000').split()[0], self.file_size)

    def request_data(self, file=False):
        method_dict = {}
        try:
            if self.environ['REQUEST_METHOD'] != 'GET':
                if file == True:
                    fileNum = 0

                    method_dict['file'] = {}
                    method_list = cgi.FieldStorage(
                        fp=self.environ['wsgi.input'],
                        environ=self.environ.copy(),
                        keep_blank_values=True)
                    for k in method_list:
                        item = method_list.getvalue(k)
                        if isinstance(item, list):
                            method_dict[self.request_method][
                                k] = method_list.getlist(k)
                        elif method_list[k].filename != None:
                            method_dict['file'][fileNum] = {
                                'filename': method_list[k].filename,
                                'value': method_list[k].value
                            }
                            fileNum = fileNum + 1
                        else:
                            method_dict[k] = method_list[k].value
                else:
                    method_dict = json.loads(self.environ['wsgi.input'].read())
            elif self.environ['REQUEST_METHOD'] == 'GET':
                if self.environ['QUERY_STRING']:
                    d = cgi.parse_qs(self.environ['QUERY_STRING'])
                    for x in d:
                        method_dict[x] = cgi.escape(d[x][0])
        except Exception as e:
            self.errorLog('request_data', e, traceback.format_exc())
        finally:
            return method_dict

    def header(self, key=None, val=None):
        if key.lower() == 'length':
            key = 'Content-Length'
            val = str(len(val))
        self.headers.append((key, val))

    def _mimetypes(self, file):
        return mimetypes.guess_type(file)[0]

    def session_register(self, userUid, environ):
        self.session_val = ""
        expiration = datetime.now() + timedelta(seconds=self.session_expires)
        sesssion_expires = expiration.strftime("%a, %d-%b-%Y %H:%M:%S GMT")
        session_lst = [self.session_name, 'KEY_VAL', 'KEY_DTA', 'KEY_HDA']
        session_dic = {}
        for x in session_lst:
            session_key = hashlib.sha256('{0}{1}'.format(
                userUid,
                datetime.now().strftime(
                    "%Y-%m-%d %H:%M:%S%f").encode()).encode()).hexdigest()
            """
			if self._session_name == 'BITINUS_DEVELOPE':
				session_dic[x] = {'name': x, 'key': session_key, 'val': "{0}={1}; Expires={2}; Max-age={3};".format(x, session_key, sesssion_expires, self.session_expires ) }
			"""
            session_dic[x] = {
                'name':
                x,
                'key':
                session_key,
                'val':
                "{0}={1}; Expires={2}; Max-age={3}; Domain={4}; path=/; Secure; HttpOnly;"
                .format(x, session_key, sesssion_expires, self.session_expires,
                        self.session_domain)
            }

        expires_time = self.session_expires
        etag = hashlib.sha224(datetime.now().strftime(
            "%Y-%m-%d %H:%M:%S%f").encode()).hexdigest()
        session_key = None
        session_data = {}
        sd = session_dic
        for x in sd:
            self.header('Set-Cookie', sd[x]['val'])
            if sd[x]['name'] == self.session_name:
                session_key = sd[x]['key']
            else:
                session_data[sd[x]['name']] = sd[x]['key']

        self.header('Pragma', 'no-cache')
        self.header('Cache-Control',
                    'no-cache, no-store, max-age=0, must-revalidate')
        self.header('Expires', '-1')
        self.header('Server', 'OctoFlowStatus Server ')
        self.header('Expt', str(expires_time))
        self.header('ETag', etag)

        session_data['USER_UID'] = userUid
        session_data['HTTP_USER_AGENT'] = environ['HTTP_USER_AGENT']

        # return session_dic
        self.redisConnect('set', session_key, str(session_data), expires_time)

    def session_delete(self, environ):
        session_dict = {}
        session_lst = [self.session_name, 'KEY_VAL', 'KEY_DTA', 'KEY_HDA']
        try:
            d = {}
            sess = environ['HTTP_COOKIE'].split(';')
            for x in sess:
                k, y = x.split('=')
                d[k.strip()] = y.strip()

            self.redis.delete(d[self.session_name])
            expiration = datetime.now() + timedelta(seconds=0)
            sesssion_expires = expiration.strftime("%a, %d-%b-%Y %H:%M:%S GMT")

            for x in session_lst:
                session_dict[
                    x] = "{0}={1}; Expires={2}; Max-age={3}; Domain={4}; path=/; Secure; HttpOnly;".format(
                        x, 'delete', sesssion_expires, 0, self.session_domain)

        except KeyError:
            pass
        except Exception as e:
            self.errorLog('session_delete', e, traceback.format_exc())
        finally:
            return session_dict

    # CM : session clear
    # DT : 2019-02-09 14:45
    # WT : [email protected]
    def session_clear(self, environ):
        sd = self.session_delete(environ)
        for x in sd:
            self.header('Set-Cookie', sd[x])
        self.header('Pragma', 'no-cache')
        self.header('Cache-Control',
                    'no-cache, no-store, max-age=0, must-revalidate')
        self.header('Expires', '-1')
        self.header('Server', 'Pinotnoir Server ')

    def session_check(self, environ):
        d = {}
        rst = False
        try:
            sess = environ['HTTP_COOKIE'].split(';')
            for x in sess:
                k, y = x.split('=')
                d[k.strip()] = y.strip()

            redis_key = d[self.session_name]
            key_validity = d['KEY_VAL']
            key_dta = d['KEY_DTA']
            key_hda = d['KEY_HDA']
            agent = environ['HTTP_USER_AGENT']

            r = self.redisConnect('get', redis_key)
            if r != None:
                r = eval(r)
                # and r['HTTP_USER_AGENT'] == agent:
                if r['KEY_VAL'] == key_validity and r[
                        'KEY_DTA'] == key_dta and r['KEY_HDA'] == key_hda:
                    user_get = self.redisConnect('get', r['USER_UID'])
                    if user_get != None:
                        user_get = eval(user_get)
                        self.session_info = user_get
                        rst = True
                    else:
                        rst = False
                else:
                    rst = False
            else:
                rst = False
        except KeyError:
            pass
        except Exception as e:
            self.errorLog('session_check', e, traceback.format_exc())
            rst = False
        finally:
            return rst

    def routing(self, environ, start_response):
        pathinfo = environ["PATH_INFO"]
        self.request_method = environ["REQUEST_METHOD"]
        try:
            rm = router.router[pathinfo]['MEHTOD']
            mo = router.router[pathinfo]['MODULE']
            fu = router.router[pathinfo]['FUNCTION']
            ss = router.router[pathinfo]['SESSION']

            if rm.upper() == self.request_method.upper():  # mehtod check
                if ss == True:  # session check
                    if self.session_check(environ) == True:
                        mod = __import__(mo, fromlist=[mo])
                        data = getattr(mod, fu)(self, environ, start_response)
                    else:
                        start_response(
                            '555 OK',
                            [('Content-Type', 'text/html'),
                             ('Content-Length', str(len('Auth Error')))])
                        data = bytes(
                            '{0} : {1}'.format(environ["PATH_INFO"],
                                               'Auth Error'), 'utf-8')
                        self.status = "209"
                        self.file_size = len(data)
                elif ss == False:
                    mod = __import__(mo, fromlist=[mo])
                    data = getattr(mod, fu)(self, environ, start_response)
            else:  # session no check
                start_response('555 OK',
                               [('Content-Type', 'text/html'),
                                ('Content-Length', str(len('METHOD DENY')))])
                data = bytes(
                    '{0} : {1}'.format(environ["PATH_INFO"], 'METHOD DENY'),
                    'utf-8')
                self.status = "444"
                self.file_size = len(data)
        except Exception as e:
            self.errorLog('routing', e, traceback.format_exc())
            self.status = "404"
            data = bytes('{0} : {1}'.format(environ["PATH_INFO"], str(e)),
                         'utf-8')
        finally:
            return data

    def application(self, environ, start_response):
        #signal.signal(signal.SIGINT, self.stop)
        #signal.signal(signal.SIGTERM, self.stop)

        if environ['HTTP_HOST'] in config.sessionDomain:
            self.session_domain = environ['HTTP_HOST']

        self.txid = str(uuid.uuid4())
        self.environ = environ
        self._clientAddress(environ)

        # self.postgres.connect()
        self.http_user_agent = environ['HTTP_USER_AGENT']

        self.headers = [('Content-Type', 'application/json'),
                        ('X-Powered-By', "{0} v1.0".format(self.serverName))]
        #self.memdb = memdb.MemDB(self.redisConnect, self.environ)
        #self._session_name = self.session_name
        # if environ['HTTP_HOST'].split(":")[0] in config.devHost:
        #	self._session_name = "BITINUS_DEVELOPE"

        try:
            self.time_start = timeit.default_timer()
            data = None
            mime = self._mimetypes(environ["PATH_INFO"])
            if environ["PATH_INFO"] == '/index.html' or environ[
                    "PATH_INFO"] == '/':
                data = open(os.path.join(config.webdocs, 'index.html'),
                            'rb').read()
                self.file_size = len(data)
                start_response('200 OK', [('Content-Type', 'text/html'),
                                          ('Content-Length', str(len(data)))])
            elif environ["PATH_INFO"] == '/static/img/octoflow.png':
                data = bs64.b64decode(config.octopng)
                self.file_size = len(data)
                start_response('200 OK', [('Content-Type', mime),
                                          ('Content-Length', str(len(data)))])
            elif '/static' in environ["PATH_INFO"]:
                data = open(
                    os.path.join(config.webdocs, environ["PATH_INFO"][1:]),
                    'rb').read()
                self.file_size = len(data)
                start_response('200 OK', [('Content-Type', mime),
                                          ('Content-Length', str(len(data)))])
            elif environ["PATH_INFO"] == '/favicon.ico':
                data = bs64.b64decode(config.favicon)
                self.file_size = len(data)
                start_response('200 OK', [('Content-Type', mime),
                                          ('Content-Length', str(len(data)))])
            else:
                data = self.routing(environ, start_response)

        except Exception as e:
            print(traceback.format_exc())
            # self.postgres.rollBack()
            self.status = "500"
            self.errorLog('application', e, traceback.format_exc())
            start_response('500 Not Found', [('Content-Type', 'text/html')])
            data = bytes('{0} : {1}'.format(environ["PATH_INFO"], '500'),
                         'utf-8')
            self.status = "500"
            self.file_size = len(data)
        finally:
            self.time_finish = timeit.default_timer()
            self.http_host = environ['HTTP_HOST']
            self.request_line = "%s %s %s %s" % (
                environ['REQUEST_METHOD'], environ['PATH_INFO'],
                environ['QUERY_STRING'], environ['SERVER_PROTOCOL'])
            self.session_info = {}
            """ if environ["HTTP_ACCEPT"].lower() == "text/event-stream":
				return data
			else: """
            return [data]

    def server_start(self):
        try:
            self.txid = str(uuid.uuid4())
            self.process_id = os.getpid()
            #self._redisPublish(config.serverName)
            # self.historydb.mgdb_connect('user_login')
            pool = Pool(1024)
            self.server = WSGIServer(self.listener,
                                     application=self.application,
                                     spawn=pool,
                                     handler_class=WebSocketHandler)
            #self.server = WSGIServer(self.listener, application=self.application, spawn=pool, log=self.access_log, error_log=self.error_log )
            self.server.handler_class.format_request = self.format_request
            self.server.serve_forever()
        except Exception as e:
            print("T ===========> ", e)
Example #49
0
    verb = env['REQUEST_METHOD']
    path = env['PATH_INFO']

    args = parseAndDelistArguments(env['QUERY_STRING'])
    if 'verb' in args:
        verb = args['verb'].upper()
        del args['verb']

    print 'args: ', args
    print 'path: ', path

    if path == '/favicon.ico':
        start_response('301 Moved Permanently',
                       [('Location', 'http://hyperdrive.me/favicon.ico')])
        return ''


# 	domain = args['domain']
# 	path = args['path'][1:]
# 	persisted_data = domains.get(domain)

    start_response('200 OK', [('Content-Type', 'text/plain')])
    return 'true'

if __name__ == '__main__':
    wsgi_port = 8882
    print 'serving on %s...' % wsgi_port
    WSGIServer(('', wsgi_port), application).serve_forever()

# http://localhost:8882/hello?data=world
Example #50
0
    def __init__(self, halt_event):
        self._log = logging.getLogger("WebWriter")
        memcached_client = memcache.Client(_memcached_nodes)

        self._interaction_pool = gdbpool.interaction_pool.DBInteractionPool(
            get_central_database_dsn(),
            pool_name=_central_pool_name,
            pool_size=_database_pool_size,
            do_log=True)

        authenticator = InteractionPoolAuthenticator(memcached_client,
                                                     self._interaction_pool)

        # Ticket #25: must run database operation in a greenlet
        greenlet = gevent.Greenlet.spawn(_get_cluster_row_and_node_row,
                                         self._interaction_pool)
        greenlet.join()
        self._cluster_row, node_row = greenlet.get()

        self._unified_id_factory = UnifiedIDFactory(node_row.id)

        self._deliverator = Deliverator()

        self._zeromq_context = zmq.Context()

        self._pull_server = GreenletPULLServer(self._zeromq_context,
                                               _web_writer_pipeliner_address,
                                               self._deliverator)
        self._pull_server.link_exception(self._unhandled_greenlet_exception)

        self._data_writer_clients = list()
        for node_name, address in zip(_node_names, _data_writer_addresses):
            resilient_client = GreenletResilientClient(
                self._zeromq_context,
                node_name,
                address,
                _client_tag,
                _web_writer_pipeliner_address,
                self._deliverator,
                connect_messages=[])
            resilient_client.link_exception(self._unhandled_greenlet_exception)
            self._data_writer_clients.append(resilient_client)

        self._space_accounting_dealer_client = GreenletDealerClient(
            self._zeromq_context, _local_node_name,
            _space_accounting_server_address)
        self._space_accounting_dealer_client.link_exception(
            self._unhandled_greenlet_exception)

        push_client = GreenletPUSHClient(
            self._zeromq_context,
            _local_node_name,
            _space_accounting_pipeline_address,
        )

        self._accounting_client = SpaceAccountingClient(
            _local_node_name, self._space_accounting_dealer_client,
            push_client)

        self._event_push_client = EventPushClient(self._zeromq_context,
                                                  "web-server")

        # message sent to data writers telling them the server
        # is (re)starting, thereby invalidating any archives
        # that are in progress for this node
        unified_id = self._unified_id_factory.next()
        timestamp = create_timestamp()
        self._event_push_client.info("web-writer-start",
                                     "web writer (re)start",
                                     unified_id=unified_id,
                                     timestamp_repr=repr(timestamp),
                                     source_node_name=_local_node_name)

        id_translator_keys_path = os.environ.get(
            "NIMBUS_IO_ID_TRANSLATION_KEYS",
            os.path.join(_repository_path, "id_translator_keys.pkl"))
        with open(id_translator_keys_path, "r") as input_file:
            id_translator_keys = pickle.load(input_file)

        self._id_translator = InternalIDTranslator(
            id_translator_keys["key"], id_translator_keys["hmac_key"],
            id_translator_keys["iv_key"], id_translator_keys["hmac_size"])

        redis_queue = gevent.queue.Queue()

        self._redis_sink = OperationalStatsRedisSink(halt_event, redis_queue,
                                                     _local_node_name)
        self._redis_sink.link_exception(self._unhandled_greenlet_exception)

        self.application = Application(self._cluster_row,
                                       self._unified_id_factory,
                                       self._id_translator,
                                       self._data_writer_clients,
                                       authenticator, self._accounting_client,
                                       self._event_push_client, redis_queue)
        self.wsgi_server = WSGIServer((_web_writer_host, _web_writer_port),
                                      application=self.application,
                                      backlog=_wsgi_backlog)
Example #51
0
        return str()

    # Launch a shell on the remote server and bridge the connection
    # This won't return as long as the session is alive
    bridge.shell()

    # Alternatively, you can run a command on the remote server
    # bridge.execute('/bin/ls -l /')

    # We have to manually close the websocket and return an empty response,
    # otherwise flask will complain about not returning a response and will
    # throw a 500 at our websocket client
    request.environ['wsgi.websocket'].close()
    return str()


if __name__ == '__main__':
    from gevent.pywsgi import WSGIServer
    from geventwebsocket.handler import WebSocketHandler

    app.debug = True
    http_server = WSGIServer(('localhost', 5000),
                             app,
                             log=None,
                             handler_class=WebSocketHandler)
    print('Server running on ws://localhost:5000/remote')
    try:
        http_server.serve_forever()
    except KeyboardInterrupt:
        pass
Example #52
0
def server():
    http_server = WSGIServer(('0.0.0.0', 5000), app)
    http_server.serve_forever()
Example #53
0
    assert 0 < p < 2**1025


@app.route('/oracle', methods=['GET'])
@ORACLE_TIME.time()
def oracle():
    try:
        x = int(request.args['x']) % p
    except Exception:
        return Response("(._.)???", mimetype="text/plain; charset=utf8")
    return Response(str(pow(x, s, p)), mimetype="text/plain; charset=utf8")


@app.route('/flag', methods=['GET'])
@FLAG_TIME.time()
def flag():
    try:
        x = int(request.args['x']) % p
    except Exception:
        return Response("(._.)???", mimetype="text/plain; charset=utf8")
    if pow(x, s, p) == 1337:
        return Response(FLAG, mimetype="text/plain; charset=utf8")
    else:
        return Response("{>_<}!!!", mimetype="text/plain; charset=utf8")


app.wsgi_app = DispatcherMiddleware(app.wsgi_app,
                                    {'/metrics': make_wsgi_app()})
if __name__ == '__main__':
    WSGIServer(('0.0.0.0', 27492), app).serve_forever()
Example #54
0
            }
            return jsonify(data)
        except:
            print(sys.exc_info()[0])
            print(sys.exc_info()[1])


@app.route("/writeLED/<status>")
def writePin(status):

    if status == 'On':
        response = ledOn()
    else:
        response = ledOff()

    return response


@app.route("/")
def mainpage():
    return render_template('index.html')


if __name__ == '__main__':
    try:
        http_server = WSGIServer(('0.0.0.0', 80), app)
        app.debug = True
        http_server.serve_forever()
    except:
        print("Exception")
Example #55
0
			print "restore:",restoreState
			
			time.sleep(.1)
			
		except Exception as x:
			print "STATES: An error occured:",x
			
app = Flask(__name__)
app.debug = True

# Simple catch-all server
@app.route('/', defaults={'path': ''}, methods=['GET', 'POST'])
@app.route('/<path:path>', methods=['GET', 'POST'])
def catch_all(path):
    return render_template('show_data.html', templateAvailable=availableInfo)

if __name__ == '__main__':
    http_server = WSGIServer(('', 8080), app)
    srv_greenlet = gevent.spawn(http_server.start)
    
    stateAssignmentThread = gevent.spawn(manageStates)
    restoreThread = gevent.spawn(makeRestoreToAvailableState)
    
    stateAssignmentThread.start()   
    restoreThread.start()
    
    try:
        gevent.joinall([srv_greenlet, stateAssignmentThread, restoreThread])
    except KeyboardInterrupt:
        print "Exiting"
Example #56
0
        abort(400)

    pic = BytesIO()
    pic.write(base64.b64decode(bytes(data["image"], encoding='utf8')))
    pic.seek(0)
    file_bytes = np.asarray(bytearray(pic.read()), dtype=np.uint8)

    img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)[..., ::-1]

    raw_result = blackmanba(img)

    result = {
        'retid': data['reqid'],
        'rettime': datetime.datetime.now().strftime('%Y%m%d%H%M%S'),
    }
    result.update(raw_result)
    print(raw_result)
    print(raw_result['feature_vector'])
    name,dis=nearest_face(raw_result['feature_vector'])
    result['name']=name
    result['distance']=dis
    result = json.dumps(result)
    return jsonify(result)


if __name__ == '__main__':
    ip = '0.0.0.0'
    post = 5000
    print('running server http://{0}'.format(ip + ':' + str(post)))
    WSGIServer((ip, post), app).serve_forever()
Example #57
0
        output += '<tr><th>Classification</th><th>Model</th><th>Confidence</th><th>Time</th><th>Top1-Acc</th><th>Top5-Acc</th></tr>'

        # feed predict_image(model_name, top1_acc, top5_acc, ptime, confidence, label) directly into html
        html_content_list = [
            '<tr><td>%s </td><td>%s</td><td>%s%%</td><td> %ss </td><td> %s%% </td><td> %s%% </td></tr>'
            % predict_image(image_path, key, values)
            for key, values in mymodels.model_data.items()
        ]

        output += '\n'.join(html_content_list)
        output += '</table>'

        toc = time()
        print("Total time for all predictions >> %.2f s" % (toc - tic))

        return output
    return None


if (__name__ == '__main__'):

    print('*** Starting WSGI Server...')
    print('****************************************************')
    print('*** Server is available at http://127.0.0.1:5000')
    print('****************************************************')

    # Get wsgi server to replace flask app.run()
    from gevent.pywsgi import WSGIServer
    web_server = WSGIServer(('', 5000), app)
    web_server.serve_forever()
Example #58
0
class GeventServer(CommonServer):
    def __init__(self, app):
        super(GeventServer, self).__init__(app)
        self.port = config['longpolling_port']
        self.httpd = None

    def process_limits(self):
        restart = False
        if self.ppid != os.getppid():
            _logger.warning("LongPolling Parent changed", self.pid)
            restart = True
        rss, vms = memory_info(psutil.Process(self.pid))
        if vms > config['limit_memory_soft']:
            _logger.warning('LongPolling virtual memory limit reached: %s',
                            vms)
            restart = True
        if restart:
            # suicide !!
            os.kill(self.pid, signal.SIGTERM)

    def watchdog(self, beat=4):
        import gevent
        self.ppid = os.getppid()
        while True:
            self.process_limits()
            gevent.sleep(beat)

    def start(self):
        import gevent
        try:
            from gevent.pywsgi import WSGIServer
        except ImportError:
            from gevent.wsgi import WSGIServer

        if os.name == 'posix':
            # Set process memory limit as an extra safeguard
            _, hard = resource.getrlimit(resource.RLIMIT_AS)
            resource.setrlimit(resource.RLIMIT_AS,
                               (config['limit_memory_hard'], hard))
            signal.signal(signal.SIGQUIT, dumpstacks)
            signal.signal(signal.SIGUSR1, log_ormcache_stats)
            gevent.spawn(self.watchdog)

        self.httpd = WSGIServer((self.interface, self.port), self.app)
        _logger.info('Evented Service (longpolling) running on %s:%s',
                     self.interface, self.port)
        try:
            self.httpd.serve_forever()
        except:
            _logger.exception(
                "Evented Service (longpolling): uncaught error during main loop"
            )
            raise

    def stop(self):
        import gevent
        self.httpd.stop()
        gevent.shutdown()

    def run(self, preload, stop):
        self.start()
        self.stop()
Example #59
0
class WebhookServer():
    def __init__(self, bot):
        self.bot = bot
        self.routes = {}
        self.app = falcon.API()
        self.app.add_sink(self.handle, '/')

        self.logger = logging.getLogger(__name__)
        self.server = WSGIServer(('', 8080), self.app, log=None)

    def start(self):
        self.logger.debug('Spawning WebhookServer greenlet')
        self.server.serve_forever()

    def get_webhooks(self):
        for plugin in self.bot.plugins:
            if plugin.enabled is False:
                continue

            for webhook in plugin.webhooks:
                yield webhook

    def handle(self, request, response):
        start_time = time.time()

        for webhook in self.get_webhooks():
            if not request.path == webhook.route:
                continue
            else:
                if request.method not in webhook.methods:
                    continue
                else:
                    try:
                        if request.method in ["POST", "PATCH"]:
                            request_data = json.loads(request.stream.read())
                        elif request.method == "GET":
                            request_data = request.params
                        else:
                            request_data = {}

                        ret = webhook.callback(request_data, request.headers)

                        if isinstance(ret, str):
                            response.body = ret
                        elif isinstance(ret, dict):
                            response.body = json.dumps(ret)

                        response.status = falcon.HTTP_200
                        break

                    except Exception as e:
                        self.logger.warning(
                            f'Caught exception handling webhook: {e}')
                        response.status = falcon.HTTP_500
                        break
        else:
            response.status = falcon.HTTP_404

        dash = "-"
        line = (f"{request.method.upper()} "
                f"{request.path} "
                f"{request.content_length or dash} "
                f"{request.host} "
                f"{request.user_agent or dash} "
                f"{time.time() - start_time:.2f}ms "
                f"{response.status}")
        self.logger.info(line)
        return response
Example #60
0
def data_loop(wsock, message):
    try:
        while True:
            data = lora.get_data()
            wsock.send(json.dumps({"action": "payload_data", "data": data}))

            time.sleep(5)
    except:
        print("WebSocketError, finish thread")


lora = Lora(simulate=config.simulate, storage_manager=storage_manager)
app.debug = True
server = WSGIServer(("0.0.0.0", config.server_port),
                    app,
                    handler_class=WebSocketHandler)
try:
    print("Serving on IP: {}".format(socket.gethostbyname(
        socket.gethostname())))
except:
    print('Serving on IP: 0.0.0.0')
print("Serving on port: {}".format(config.server_port))

try:
    server.serve_forever()
except KeyboardInterrupt:
    print('Script interrupted. Software is not running now!')
    try:
        sys.exit(0)
    except SystemExit: