def main():
parse_command_line()
app = tornado.web.Application(
[
(r"/", MainHandler),
(r"/socket.io/", socketio.get_tornado_handler(sio)),
],
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
debug=options.debug,
)
app.listen(options.port)
tornado.ioloop.IOLoop.current().start()
def __init__(self, db, queue, port=9999, debug=False):
Process.__init__(self)
self.queue = queue
self.db = db
self._port = port
self._debug = debug
"""Socket.IO - Definition."""
self.sio = socketio.AsyncServer(async_mode='tornado')
self.sio.register_namespace(CaseNamespace('/case'))
self.sio.register_namespace(PCAPNamespace('/pcap'))
self.sio.on("connect", websockets.connect, "/")
self.sio.on("disconnect", websockets.connect, "/")
"""Tornado Web Server - Definition."""
self._app = tornado.web.Application(
[
# Socket.IO
(r"/socket.io/", socketio.get_tornado_handler(self.sio)),
# PCAP
(r'/api/pcap/upload', PCAPUploadHandler),
# Case
(r'/api/case/hash', HumanHashHandler),
(r'/api/case/upload', UploadCaseHandler),
(r'/api/case/metadata', MetadataHandler),
(r'/api/case/object/delete', case.DeleteObjectHandler),
#(r'/api/case/analyze', AnalyzeCaseHandler),
(r'/api/case/run', RunCaseHandler),
(r'/api/case/(.*)', SingleHandler),
# CaseObjects
(r'/api/object/update', UpdateObjectHandler),
(r'/api/object/analyze', AnalyzeObjectHandler),
(r'/api/object/upload', UploadObjectHandler),
(r'/api/object/delete', DeleteObjectHandler),
# Administration
(r'/api/settings/insert', SettingsInsertHandler),
(r'/api/settings/delete', SettingsDeleteHandler),
(r'/api/settings/get/(.*)', SettingsGetHandler),
# Frontend
(r'/(favicon.ico)', tornado.web.StaticFileHandler, {
"path": os.path.join(dir_path, "..", "dist")
}),
(r'/(.*)', tornado.web.StaticFileHandler, {
"default_filename": "index.html",
'path': os.path.join(dir_path, "..", "dist")
}),
],
debug=False)
def main():
parse_command_line()
app = tornado.web.Application(
[
(r'/socket.io/', socketio.get_tornado_handler(sio)),
(r'/(.*)', tornado.web.StaticFileHandler, {
'path': 'public',
'default_filename': 'index.html'
}),
],
debug=options.debug,
)
app.listen(options.port)
IOLoop.current().start()
def main():
parse_command_line()
app = tornado.web.Application(
[
(r"/", MainHandler),
(r"/debug", DebugHandler),
(r"/socket.io/", socketio.get_tornado_handler(sio)),
(r'/(.*)', tornado.web.StaticFileHandler, {
'path': os.path.join(os.path.dirname(__file__), 'client')
}),
],
template_path=os.path.join(os.path.dirname(__file__), "client"),
debug=options.debug,
)
sio.start_background_task(background_task)
app.listen(options.port)
tornado.ioloop.IOLoop.current().start()
def __init__(self, config, mongo, peers):
static_path = path.join(path.dirname(__file__), 'static')
self.default_handlers = [(r"/(apple-touch-icon\.png)",
StaticFileHandler, dict(path=static_path)),
(r"/socket.io/",
socketio.get_tornado_handler(get_sio()))]
self.default_handlers.extend(NODE_HANDLERS)
self.default_handlers.extend(GRAPH_HANDLERS)
# TODO: use config to enable/disable specific routes
self.default_handlers.extend(EXPLORER_HANDLERS)
if config.max_miners > 0:
self.default_handlers.extend(POOL_HANDLERS)
self.default_handlers.extend(WALLET_HANDLERS)
for finder, name, ispkg in pkgutil.iter_modules(
[path.join(path.dirname(__file__), 'plugins')]):
handlers = importlib.import_module('plugins.' + name + '.handlers')
self.default_handlers.extend(handlers.HANDLERS)
self.default_handlers.extend(WEB_HANDLERS)
settings = dict(
app_title=u"Yadacoin Node",
template_path=path.join(path.dirname(__file__), 'templates'),
xsrf_cookies=
False, # TODO: sort out, depending on python client version (< 3.6) does not work with xsrf activated
cookie_secret=sha256(
config.private_key.encode('utf-8')).hexdigest(),
compress_response=True,
debug=options.debug, # Also activates auto reload
serve_traceback=options.debug,
yadacoin_vars={'node_version': __version__},
yadacoin_config=config,
mp=None,
mongo=mongo,
peers=peers,
version=__version__,
protocol_version=PROTOCOL_VERSION,
BU=yadacoin.blockchainutils.GLOBAL_BU,
TU=yadacoin.transactionutils.TU)
handlers = self.default_handlers.copy()
super().__init__(handlers, **settings)
def __init__(self):
handlers = [
tornado.web.url(r'/', MainHandler.IndexHandler, name='index'),
tornado.web.url(r'/camera',
MainHandler.CamHandler,
name='camera'),
tornado.web.url(r'/login',
MainHandler.LoginHandler,
name='login'),
tornado.web.url(r'/logout',
MainHandler.LogoutHandler,
name='logout'),
(r"/socket.io/", socketio.get_tornado_handler(sio))
]
settings = dict(
debug=True, # 调试模式，修改后自动重启服务，不需要自动重启，生产情况下切勿开启，安全性
template_path=os.path.join(os.path.dirname(__file__),
"templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
login_url='/login', # 没有登录则跳转至此
cookie_secret='guijutech@!', # 加密cookie的字符串
xsrf_cookie=True,
pycket={ # 固定写法packet，用于保存用户登录信息
'engine': 'redis',
'storage': {
'host': 'localhost',
'port': 6379,
'db_sessions': 15,
'db_notifications': 11,
'max_connections': 2**33,
},
'cookie': {
'expires_days': 1,
'max_age': 100
}
})
super(Application, self).__init__(
handlers, **settings
) # 用super方法将父类的init方法重新执行一遍，然后将handlers和settings传进去，完成初始化
def main():
try:
host_name = socket.gethostname()
host_ip = socket.gethostbyname(host_name)
print("Hostname : ", host_name)
print("IP : ", host_ip)
except:
print("Unable to get Hostname and IP")
parse_command_line()
app = tornado.web.Application(
[
(r"/socket.io/", socketio.get_tornado_handler(sio)),
],
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
debug=options.debug,
)
app.listen(options.port)
tornado.ioloop.IOLoop.current().spawn_callback(user_routine)
tornado.ioloop.IOLoop.current().start()
'public_key': conference_reference.participant.public_key
}
},
'read':
last_message.read,
'readAt':
last_message.read_at.timestamp()
if last_message.read_at is not None else last_message.read_at,
'date':
last_message.date.timestamp(),
'type':
last_message.type,
'content':
last_message.content,
'consumed':
last_message.consumed,
'edited':
last_message.edited
}
return json
if __name__ == '__main__':
app = tornado.web.Application([(r"/socket.io/",
socketio.get_tornado_handler(sio))])
app.listen(8080)
tornado.ioloop.IOLoop.current().start()
from tornado.web import RequestHandler
import json
import socketio
from socketio import AsyncNamespace
# WebSocket Namespaces
from routes.api.guids import Guilds
sio = socketio.AsyncServer(async_mode="tornado")
_Handler = socketio.get_tornado_handler(sio)
config = json.load(open("config/web.json"))
CORS_ORGINS = config["CORS_ORGINS"]
class PrimaryHandler(RequestHandler):
def get_current_user(self):
userIDCookie = self.get_secure_cookie("userauthtoken")
if userIDCookie is not None:
return userIDCookie.decode()
else:
return None
def set_default_headers(self):
for cor_orgin in CORS_ORGINS:
self.set_header("Access-Control-Allow-Origin", cor_orgin)
self.set_header("Access-Control-Allow-Headers", "x-requested-with")
self.set_header("Access-Control-Allow-Credentials", "true")
self.set_header('Access-Control-Allow-Methods', 'POST, GET, OPTIONS')
print(
f'Boomba: {len([e for e in self.room if isinstance(e, Explosion)])}'
)
for i, p in enumerate(
sorted([e for e in self.room if isinstance(e, Player)],
key=lambda x: x.uuid)):
print(f'Player {p.uuid}, x={p.x}, y={p.y}')
cursesman_server = CursesmanServer()
sids = []
sio = socketio.AsyncServer(async_mode='tornado')
app = tornado.web.Application([
(r"/socket.io/", socketio.get_tornado_handler(sio)),
], )
async def broadcast_update(room_state):
await sio.emit('room_server_refresh', pickle.dumps(room_state))
@sio.event
def room_event(sid, data):
# update internal room representation
room = pickle.loads(data)
print(room)
# resolve conflicts
cursesman_server.update_room(room)
logger = logging.getLogger('anthill.application')
socketio_server = socketio.AsyncServer(
client_manager=socketio.AsyncRedisManager('redis://', logger=logger),
async_mode='tornado',
engineio_logger=logger,
logger=logger,
ping_timeout=settings.WEBSOCKET_PING_TIMEOUT,
ping_interval=settings.WEBSOCKET_PING_INTERVAL,
max_http_buffer_size=settings.WEBSOCKET_MAX_MESSAGE_SIZE,
cookie=settings.SESSION_COOKIE_NAME)
socketio_client = socketio.AsyncClient(logger=logger,
engineio_logger=logger,
reconnection_delay=1,
reconnection_delay_max=600)
BaseSocketIOHandler = socketio.get_tornado_handler(socketio_server)
class SocketIOHandler(TranslationHandlerMixin, LogExceptionHandlerMixin,
SessionHandlerMixin, CommonRequestHandlerMixin,
BaseSocketIOHandler):
clients = None
def __init__(self, application, request, **kwargs):
super().__init__(application, request, **kwargs)
self.settings.update(
websocket_ping_interval=settings.WEBSOCKET_PING_INTERVAL)
self.settings.update(
websocket_ping_timeout=settings.WEBSOCKET_PING_TIMEOUT)
self.settings.update(
websocket_max_message_size=settings.WEBSOCKET_MAX_MESSAGE_SIZE)
import sio
import socketio
import tornado.ioloop
import tornado.web
from controller.rest.main_handler import MainHandler
from controller.rest.story_handler import StoryHandler
from controller.socket.table_handler import TableHandler
socket_server = socketio.AsyncServer(async_mode='tornado',
cors_allowed_origins='*')
if __name__ == "__main__":
app = tornado.web.Application([
(r"/", MainHandler), (r"/story/([0-9]+)", StoryHandler, dict(db="13")),
(r"/socket.io/", socketio.get_tornado_handler(socket_server))
])
print('Starting Web Application')
# defining socket namespaces
socket_server.register_namespace(TableHandler('/'))
# start server
app.listen(1234)
tornado.ioloop.IOLoop.current().start()
def make_app():
return tornado.web.Application([
(r"/websocket/", socketio.get_tornado_handler(sio)),
])
def make_app():
return tornado.web.Application([
# test page
(r"/send", SendMessageHandler),
(r"/websocket/", socketio.get_tornado_handler(sio)),
])
def make_app():
return tornado.web.Application([
(r"/socket.io/", socketio.get_tornado_handler(sio)),
(r"/ws", WebSocketHandler),
], )
def __init__(self, port):
super().__init__()
self.sio = sio
self.port = port
# robot arm
rev_config1 = {
"Link": [0, 0, 1.45],
"RotAxis": [0, 0, 1],
"AngleLimits": [0, 2 * np.pi]
}
rev_config2 = {
"Link": [0, 0, 1.45],
"RotAxis": [0, 1, 0],
"AngleLimits": [0, 2 * np.pi]
}
rev_config3 = {
"Link": [0, 0, 2.7],
"RotAxis": [0, 1, 0],
"AngleLimits": [0, 2 * np.pi]
}
rev_config4 = {
"Link": [1.35, 0, 0],
"RotAxis": [1, 0, 0],
"AngleLimits": [0, 2 * np.pi]
}
rev_config5 = {
"Link": [1.35, 0, 0],
"RotAxis": [0, 1, 0],
"AngleLimits": [0, 2 * np.pi]
}
rev_config6 = {
"Link": [0.7, 0, 0],
"RotAxis": [1, 0, 1],
"AngleLimits": [0, 2 * np.pi]
}
robot_arm_config = [
("Revolute", rev_config1), ("Revolute", rev_config2),
("Revolute", rev_config3), ("Revolute", rev_config4),
("Revolute", rev_config5), ("Revolute", rev_config6)
]
# self.robot_arm_handle = RobotArmHandler('/robot-control', robot_arm_config)
# self.sio.register_namespace(self.robot_arm_handle)
# self.robot_depth_image_handle = RobotDepthImageHandler('/depth-camera')
# self.sio.register_namespace(self.robot_depth_image_handle)
self.rc3dr = RC3DR('/rc3dr')
self.sio.register_namespace(self.rc3dr)
settings = {
"static_path": os.path.join(os.path.dirname(__file__), "static"),
"template_path": os.path.join(os.path.dirname(__file__),
"templates"),
}
app = tornado.web.Application(
[
(r"/", MainHandler),
(r"/socket.io/", socketio.get_tornado_handler(sio)),
(r'/media/models/obj/(.*)', tornado.web.StaticFileHandler, {
'path': './media/models/obj'
}),
(r'/media/models/urdf/(.*)', tornado.web.StaticFileHandler, {
'path': './media/models/urdf'
}),
], **settings
) # passing static_path="..." automatically creates tornado.web.StaticFileHandler
app.listen(port)
