Python SocketIO.on方法代码示例

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import on [as 别名]
class CarpentryHttpServer(Web):

    def __init__(self, log_level=logger.info, *args, **kw):
        super(CarpentryHttpServer, self).__init__(*args, **kw)
        setup_logging(log_level)

        self.flask_app.config.from_object('carpentry.conf')
        self.github = GitHub(self.flask_app)
        self.prepare_services_integration()

    def prepare_services_integration(self):
        self.setup_github_authentication()
        MODULES.clear()
        # self.collect_websocket_modules()
        self.collect_modules()

    def collect_websocket_modules(self):
        self.socket_io = SocketIO(self.flask_app)
        self.websockets = []
        for event, handler in WEBSOCKET_HANDLERS.items():
            register = self.socket_io.on(event)
            self.websockets.append(register(handler))

        return self.websockets

    def setup_github_authentication(self):
        @self.flask_app.before_request
        def prepare_user():
            carpentry_token = request.cookies.get('carpentry_token')
            g.user = User.from_carpentry_token(carpentry_token)

        @self.github.access_token_getter
        def token_getter():
            user = g.user
            if user is not None:
                return user.github_access_token

        @self.flask_app.route('/oauth/github.com')
        @self.github.authorized_handler
        def authorized(access_token):
            next_url = request.args.get('next') or conf.get_full_url('/')
            access_token = access_token or request.args.get('access_token')

            if access_token is None:
                logging.warning(
                    "No access token retrieved, set the log level "
                    "to debug and check flask-github's output. "
                    "You likely set the wrong github client id "
                    "and secret", access_token)
                return redirect(next_url)

            users = User.objects.filter(github_access_token=access_token)
            user_exists = len(users) > 0

            if not user_exists:
                g.user = User(
                    id=uuid.uuid1(),
                    carpentry_token=uuid.uuid4(),
                    github_access_token=access_token
                )
                logger.info("created new user %s", g.user)
            else:
                logger.info(
                    "User already exists with github_access_token %s %s", access_token, g.user)
                g.user = users[0]
                g.user.carpentry_token = uuid.uuid4()
                g.user.github_access_token = access_token

            g.user.save()

            logging.warning("authorized: %s - token: %s", g.user, access_token)

            response = redirect(next_url)
            response.set_cookie(
                'carpentry_token',
                bytes(g.user.carpentry_token),
            )
            return response

        @self.flask_app.route('/login', methods=["GET"])
        def login():
            response = self.github.authorize(
                scope='repo_deployment,repo,user,gist,write:repo_hook,repo:status,org:admin,admin:org_hook')
            return response

        @self.flask_app.route('/logout', methods=["GET"])
        def logout():
            response = redirect('/')
            if g.user:
                g.user.reset_token()

            response.set_cookie('carpentry_token', '', expires=0)
            return response

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import on [as 别名]
import eventlet
eventlet.monkey_patch() # for flask_socketio message queue support

from app import create_app
from app.routes import routes, handlers
from flask_socketio import SocketIO

app = create_app(blueprints=[routes])
socketio = SocketIO(app, message_queue='redis://localhost:6379')

# have to do this manually
for msg, funcs in handlers.items():
    for ns, func in funcs.items():
        socketio.on(msg, namespace=ns)(func)

socketio.run(app, host='0.0.0.0', port=5000, debug=True)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import on [as 别名]
from flask_socketio import SocketIO

#sio = SocketIO(message_queue="redis://")
sio = SocketIO(message_queue="amqp://")

from socketIO_client import SocketIO

def on_chat_response(*args):
    print 'on_chat_response', args

print "Getting sio"
socketIO = SocketIO('localhost', 80)
print "Got sio", socketIO
socketIO.on('chat', on_chat_response)
socketIO.emit('chat', "hello")
socketIO.wait(seconds=3)

# 需要导入模块: from flask_socketio import SocketIO [as 别名]
# 或者: from flask_socketio.SocketIO import on [as 别名]
class App:
    """Core class to layout, connect, build a Bowtie app."""

    def __init__(self, name='__main__', app=None, rows: int = 1, columns: int = 1,
                 sidebar: bool = False, title: str = 'Bowtie App',
                 theme: Optional[str] = None, background_color: str = 'White',
                 socketio: str = '', debug: bool = False) -> None:
        """Create a Bowtie App.

        Parameters
        ----------
        name : str, optional
            Use __name__ or leave as default if using a single module.
            Consult the Flask docs on "import_name" for details on more
            complex apps.
        app : Flask app, optional
            If you are defining your own Flask app, pass it in here.
            You only need this if you are doing other stuff with Flask
            outside of bowtie.
        row : int, optional
            Number of rows in the grid.
        columns : int, optional
            Number of columns in the grid.
        sidebar : bool, optional
            Enable a sidebar for control components.
        title : str, optional
            Title of the HTML.
        theme : str, optional
            Color for Ant Design components.
        background_color : str, optional
            Background color of the control pane.
        socketio : string, optional
            Socket.io path prefix, only change this for advanced deployments.
        debug : bool, optional
            Enable debugging in Flask. Disable in production!

        """
        self.title = title
        self.theme = theme
        self._init: Optional[Callable] = None
        self._socketio_path = socketio
        self._schedules: List[Scheduler] = []
        self._subscriptions: Dict[Event, List[Tuple[List[Event], Callable]]] = defaultdict(list)
        self._pages: Dict[Pager, Callable] = {}
        self._uploads: Dict[int, Callable] = {}
        self._root = View(rows=rows, columns=columns, sidebar=sidebar,
                          background_color=background_color)
        self._routes: List[Route] = []

        self._package_dir = Path(os.path.dirname(__file__))
        self._jinjaenv = Environment(
            loader=FileSystemLoader(str(self._package_dir / 'templates')),
            trim_blocks=True,
            lstrip_blocks=True
        )
        if app is None:
            self.app = Flask(name)
        else:
            self.app = app
        self.app.debug = debug
        self._socketio = SocketIO(self.app, binary=True, path=socketio + 'socket.io')
        self.app.secret_key = secrets.token_bytes()
        self.add_route(view=self._root, path='/', exact=True)

        # https://buxty.com/b/2012/05/custom-template-folders-with-flask/
        templates = Path(__file__).parent / 'templates'
        self.app.jinja_loader = ChoiceLoader([
            self.app.jinja_loader,
            FileSystemLoader(str(templates)),
        ])
        self._build_dir = self.app.root_path / _DIRECTORY
        self.app.before_first_request(self._endpoints)

    def wsgi_app(self, environ, start_response):
        """Support uwsgi and gunicorn."""
        return self.app.wsgi_app(environ, start_response)

    def __call__(self, environ, start_response):
        """Support uwsgi and gunicorn."""
        return self.wsgi_app(environ, start_response)

    def __getattr__(self, name: str):
        """Export attributes from root view."""
        if name == 'columns':
            return self._root.columns
        if name == 'rows':
            return self._root.rows
        if name == 'column_gap':
            return self._root.column_gap
        if name == 'row_gap':
            return self._root.row_gap
        if name == 'border':
            return self._root.border
        if name == 'layout':
            return self._root.layout
        raise AttributeError(name)

    def __setattr__(self, name, value):
        """Set layout function for root view."""
        if name == 'layout':
#.........这里部分代码省略.........