def create_app(option={}, socket_option=None):
app = Flask( __name__, **option )
with app.app_context():
# Set Socektio
if socket_option is not None:
from socketio import WSGIApp
from .sockets import create_sio
sio = create_sio(**socket_option)
app.wsgi_app = WSGIApp(sio, app.wsgi_app)
# Set CORS
CORS(app=app, resources={
r"*": { "origin": "*" }
})
# Set Routes
from .routes import routes
return app
"""
WSGI config for SuperFarmer project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from socketio import WSGIApp
from sockets import io
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'SuperFarmer.settings')
django_application = get_wsgi_application()
application = WSGIApp(io, wsgi_app=django_application)
if endpoint == 'static':
filename = values.get('filename', None)
if filename:
file_path = os.path.join(app.static_folder, filename)
values['q'] = int(os.stat(file_path).st_mtime)
return url_for(endpoint, **values)
@app.context_processor
def override_url_for():
return dict(url_for=dated_url_for)
@app.route('/', methods=["GET", "POST"])
def index():
return render_template("index.html")
# Create SocketIO Server
sio = Server(async_mode="threading",
logger=app.logger,
engineio_logger=app.logger)
sio.register_namespace(ChatNamespace(sio, '/chat'))
# Set SocketIO WSGI Application
app.wsgi_app = WSGIApp(sio, app.wsgi_app)
if __name__ == "__main__":
dotenv.load_dotenv(dotenv_path=".env")
app.run(host="localhost", port=3000, threaded=True)
def listen(self, host='localhost', port=5050):
app = WSGIApp(self.sio)
eventlet.wsgi.server(eventlet.listen((host, port)), app)
"""
WSGI config for chat_bot project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.11/howto/deployment/wsgi/
"""
import os
from socketio import WSGIApp
from django.core.wsgi import get_wsgi_application
from apps.iosocket.views import sio
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "chat_bot.settings.production")
django_app = get_wsgi_application()
application = WSGIApp(sio, django_app)
new_message_response, sent_ack_response, receive_ack_response, register_response, send_info_response
from trace import trace_info, trace_debug
"""
TODO:: Auto Scale System Notification Implement.
Possible Solution Can be pass Server IP and make a internal emit to trigger.
"""
basicConfig(level=CRITICAL)
sio = Server()
if DEBUG:
app = WSGIApp(
sio,
static_files={
'/': 'Client.html',
'/socket.io.js': 'socket.io.js',
# '/static/style.css': 'static/style.css',
})
else:
app = WSGIApp(sio)
SCOPE_WHITE_LIST = {"telemesh"}
USER_SESSION = dict()
SESSION_SID = dict()
def set_session(sid, scope, address):
session_key = get_session_key(scope, address)
session = USER_SESSION.get(session_key, None)
def run(config=None,
plugin_providers=None,
product_name='ajenti',
dev_mode=False,
debug_mode=False,
autologin=False):
"""
A global entry point for Ajenti.
:param config: config file implementation instance to use
:type config: :class:`aj.config.BaseConfig`
:param plugin_providers: list of plugin providers to load plugins from
:type plugin_providers: list(:class:`aj.plugins.PluginProvider`)
:param str product_name: a product name to use
:param bool dev_mode: enables dev mode (automatic resource recompilation)
:param bool debug_mode: enables debug mode (verbose and extra logging)
:param bool autologin: disables authentication and logs everyone in as the user running the panel. This is EXTREMELY INSECURE.
"""
if config is None:
raise TypeError('`config` can\'t be None')
reload(sys)
if hasattr(sys, 'setdefaultencoding'):
sys.setdefaultencoding('utf8')
aj.product = product_name
aj.debug = debug_mode
aj.dev = dev_mode
aj.dev_autologin = autologin
aj.init()
aj.log.set_log_params(tag='master', master_pid=os.getpid())
aj.context = Context()
aj.config = config
aj.plugin_providers = plugin_providers or []
logging.info(f'Loading config from {aj.config}')
aj.config.load()
aj.config.ensure_structure()
logging.info('Loading users from /etc/ajenti/users.yml')
aj.users = AjentiUsers(aj.config.data['auth']['users_file'])
aj.users.load()
logging.info('Loading smtp config from /etc/ajenti/smtp.yml')
aj.smtp_config = SmtpConfig()
aj.smtp_config.load()
aj.smtp_config.ensure_structure()
if aj.debug:
logging.warning('Debug mode')
if aj.dev:
logging.warning('Dev mode')
try:
locale.setlocale(locale.LC_ALL, '')
except locale.Error:
logging.warning('Couldn\'t set default locale')
# install a passthrough gettext replacement since all localization is handled in frontend
# and _() is here only for string extraction
__builtins__['_'] = lambda x: x
logging.info(f'Ajenti Core {aj.version}')
logging.info(f'Master PID - {os.getpid()}')
logging.info(f'Detected platform: {aj.platform} / {aj.platform_string}')
logging.info(f'Python version: {aj.python_version}')
# Load plugins
PluginManager.get(aj.context).load_all_from(aj.plugin_providers)
if len(PluginManager.get(aj.context)) == 0:
logging.warning('No plugins were loaded!')
if aj.config.data['bind']['mode'] == 'unix':
path = aj.config.data['bind']['socket']
if os.path.exists(path):
os.unlink(path)
listener = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
try:
listener.bind(path)
except OSError:
logging.error(f'Could not bind to {path}')
sys.exit(1)
if aj.config.data['bind']['mode'] == 'tcp':
host = aj.config.data['bind']['host']
port = aj.config.data['bind']['port']
listener = socket.socket(
socket.AF_INET6 if ':' in host else socket.AF_INET,
socket.SOCK_STREAM)
if aj.platform not in ['freebsd', 'osx']:
try:
listener.setsockopt(socket.IPPROTO_TCP, socket.TCP_CORK, 1)
except socket.error:
logging.warning('Could not set TCP_CORK')
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
logging.info(f'Binding to [{host}]:{port}')
try:
listener.bind((host, port))
except socket.error as e:
logging.error(f'Could not bind: {str(e)}')
sys.exit(1)
listener.listen(10)
gateway = GateMiddleware.get(aj.context)
middleware_stack = HttpMasterMiddleware.all(aj.context) + [gateway]
sio = Server(async_mode='gevent',
cors_allowed_origins=aj.config.data['trusted_domains'])
application = WSGIApp(
sio,
HttpRoot(HttpMiddlewareAggregator(middleware_stack)).dispatch)
sio.register_namespace(SocketIONamespace(context=aj.context))
if aj.config.data['ssl']['enable'] and aj.config.data['bind'][
'mode'] == 'tcp':
aj.server = pywsgi.WSGIServer(
listener,
log=open(os.devnull, 'w'),
application=application,
handler_class=RequestHandler,
policy_server=False,
)
aj.server.ssl_args = {'server_side': True}
cert_path = aj.config.data['ssl']['certificate']
if aj.config.data['ssl']['fqdn_certificate']:
fqdn_cert_path = aj.config.data['ssl']['fqdn_certificate']
else:
fqdn_cert_path = cert_path
context = gevent.ssl.SSLContext(ssl.PROTOCOL_TLS)
context.load_cert_chain(certfile=fqdn_cert_path,
keyfile=fqdn_cert_path)
context.options |= ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1
context.set_ciphers(
'ALL:!ADH:!EXP:!LOW:!RC2:!3DES:!SEED:!RC4:+HIGH:+MEDIUM')
if aj.config.data['ssl']['client_auth']['enable']:
logging.info('Enabling SSL client authentication')
context.load_verify_locations(cafile=cert_path)
if aj.config.data['ssl']['client_auth']['force']:
context.verify_mode = ssl.CERT_REQUIRED
else:
context.verify_mode = ssl.CERT_OPTIONAL
## Test callback : client_certificate_callback must return None to get forward
# context.set_servername_callback(AuthenticationService.get(aj.context).client_certificate_callback)
aj.server.wrap_socket = lambda socket, **args: context.wrap_socket(
sock=socket, server_side=True)
logging.info('SSL enabled')
if aj.config.data['ssl']['force']:
from aj.https_redirect import http_to_https
target_url = f'https://{aj.config.data["name"]}:{port}'
gevent.spawn(http_to_https, target_url)
logging.info(
f'HTTP to HTTPS redirection activated to {target_url}')
else:
# No policy_server argument for http
aj.server = pywsgi.WSGIServer(
listener,
log=open(os.devnull, 'w'),
application=application,
handler_class=RequestHandler,
)
# auth.log
try:
syslog.openlog(
ident=str(aj.product),
facility=syslog.LOG_AUTH,
)
except Exception as e:
syslog.openlog(aj.product)
def cleanup():
if hasattr(cleanup, 'started'):
return
cleanup.started = True
logging.info(f'Process {os.getpid()} exiting normally')
gevent.signal_handler(signal.SIGINT, lambda: None)
gevent.signal_handler(signal.SIGTERM, lambda: None)
if aj.master:
gateway.destroy()
p = psutil.Process(os.getpid())
for c in p.children(recursive=True):
try:
os.killpg(c.pid, signal.SIGTERM)
os.killpg(c.pid, signal.SIGKILL)
except OSError:
pass
def signal_handler():
cleanup()
sys.exit(0)
gevent.signal_handler(signal.SIGINT, signal_handler)
gevent.signal_handler(signal.SIGTERM, signal_handler)
aj.server.serve_forever()
if not aj.master:
# child process, server is stopped, wait until killed
gevent.wait()
if hasattr(aj.server, 'restart_marker'):
logging.warning('Restarting by request')
cleanup()
fd = 20 # Close all descriptors. Creepy thing
while fd > 2:
try:
os.close(fd)
logging.debug(f'Closed descriptor #{fd:d}')
except OSError:
pass
fd -= 1
restart()
else:
if aj.master:
logging.debug('Server stopped')
cleanup()
from dominion.game import Game
from dominion.interactions import NetworkedCLIInteraction, BrowserInteraction, AutoInteraction
from socketio import Server, WSGIApp
# socketio = Server(async_mode='eventlet', async_handlers=True, cors_allowed_origins='*')
socketio = Server(async_mode='eventlet', async_handlers=True)
static_files = {
'/': 'static/index.html',
'/static/socket.io.js': 'static/socket.io.js',
'/static/socket.io.js.map': 'static/socket.io.js.map',
'/static/client.js': 'static/client.js',
# '/static/style.css': 'static/style.css',
}
app = WSGIApp(socketio, static_files=static_files)
# Global dictionary of games, indexed by room ID
games = {}
# Global dictionary of sids, {sid: (room, data)}
sids = {}
# Global dictionary of CPUs, indexed by room ID, {room: CPU_COUNT}
cpus = {}
@socketio.on('join room')
def join_room(sid, data):
username = data['username']
room = data['room']
def main():
args = parse_args()
logger, wsgi_logger = get_logger(args.debug)
if args.setup:
if platform.system() == 'Linux':
setup(args.user)
else:
setup()
sys.exit(0)
return
CLIENTS = {}
DEVICES = {}
sio = Server(logger=args.debug,
engineio_logger=args.debug,
cors_allowed_origins='*')
app = WSGIApp(sio)
@sio.event
def connect(sid, environ):
CLIENTS[sid] = environ['REMOTE_ADDR']
logger.info(f'Client connected from {environ["REMOTE_ADDR"]}')
logger.debug(f'Client {environ["REMOTE_ADDR"]} sessionId: {sid}')
@sio.event
def intro(sid, data):
if data['id'] == 'x360':
DEVICES[sid] = X360Device(data['device'], CLIENTS[sid])
else:
DEVICES[sid] = DS4Device(data['device'], CLIENTS[sid])
logger.info(
f'Created virtual {data["type"]} gamepad for {data["device"]} '
f'at {CLIENTS[sid]}')
@sio.event
def input(sid, data):
logger.debug(f'Received INPUT event::{data["key"]}: {data["value"]}')
DEVICES[sid].send(data['key'], data['value'])
@sio.event
def disconnect(sid):
device = DEVICES.pop(sid)
logger.info(f'Disconnected device {device.device} at {device.address}')
device.close()
try:
host = args.host or default_host()
sock = listen((host, args.port))
except PermissionError:
sys.exit(f'Port {args.port} is not available. '
f'Please specify a different port with -p option.')
logger.info(f'Listening on http://{host}:{args.port}/')
logger.info(f'Frontend Port on http://{host}:{args.frontend_port}/')
qr = qrcode.QRCode()
qr.add_data(f'http://{host}:{args.frontend_port}/')
if platform.system() == 'Windows':
import colorama
colorama.init()
qr.print_ascii(tty=True)
wsgi.server(sock, app, log=wsgi_logger, log_output=args.debug, debug=False)
"""
WSGI config for prisoners_dilemma project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/2.2/howto/deployment/wsgi/
"""
import eventlet
import os
from django.core.wsgi import get_wsgi_application
from socketio import WSGIApp
from website.sio import SERVER
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'prisoners_dilemma.settings')
application = get_wsgi_application()
application = WSGIApp(SERVER, application)
eventlet.wsgi.server(eventlet.listen(('', 8000)), application)
# -*- coding: utf-8 -*-
"""
sio.py
Created on Tue Sep 17 13:01:26 2019
@author: Sarah
"""
from socketio import Server, WSGIApp
from .wsgi import application
server = Server()
@server.event
def double(sid, data):
number = int(data.number)
number *= 2
server.emit('double response', {'result': number}, room=sid)
sioApp = WSGIApp(server, application)
def main() -> None:
logging.basicConfig(level=logging.DEBUG, format='[%(levelname)s] [%(module)s] %(message)s')
app = WSGIApp(server)
eventlet.wsgi.server(eventlet.listen(("0.0.0.0", 3773)), app)
def handle(self, *args, **kwargs):
eventlet.monkey_patch()
app = WSGIApp(sio)
eventlet.wsgi.server(eventlet.listen(('', settings.SIO_SERVER_PORT)),
app)
"""
WSGI config for dummyapp project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/2.2/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from socketio import WSGIApp
from double.views import server
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'dummyapp.settings')
application = get_wsgi_application()
application = WSGIApp(server, application)
import eventlet
eventlet.wsgi.server(eventlet.listen(('', 8000)), application)
def run(host="localhost", port=3000):
app.wsgi_app = WSGIApp(sio, app.wsgi_app)
app.run(host=host, port=int(port), threaded=True)
