[uwsgi]
    autoload        = true
    plugins         = python3
    master          = true
    workers         = 1
    threads         = 1
    harakiri        = 30 
    max-requests    = 5000
    chdir           = /ws/pycms.ws/src
    pythonpath      = /ws/pycms.ws/src
    pythonpath      = /ws/.pyvenv/main/lib/python3.6/site-packages
    virtualenv      = /ws/.pyvenv/main
    module          = wsgi:application
    chmod-socket    = 777
    socket          = /run/uwsgi/getws.sock
    logfile-chmod   = 664
    logto           = /ws/pycms.ws/logs/uwsgi.log

dnf install zlib-devel openssl-devel

./configure 
make
make altinstall

python3.6 -m venv .pyvenv/main

dnf install uwsgi-plugin-python3 --enablerepo=updates-testing

[uWSGI] getting INI configuration from pycms.ws.ini
*** Starting uWSGI 2.0.14 (64bit) on [Sun Jan 15 18:06:04 2017] ***
compiled with version: 6.3.1 20161221 (Red Hat 6.3.1-1) on 13 January 2017 23:06:38
os: Linux-4.9.3-200.fc25.x86_64 #1 SMP Fri Jan 13 01:01:13 UTC 2017
nodename: localhost.localdomain
machine: x86_64
clock source: unix
pcre jit disabled
detected number of CPU cores: 4
current working directory: /etc/uwsgi.d
detected binary path: /usr/sbin/uwsgi
chdir() to /ws/pycms.ws/src
your processes number limit is 15216
your memory page size is 4096 bytes
 *** WARNING: you have enabled harakiri without post buffering. Slow upload could be rejected on post-unbuffered webservers *** 
detected max file descriptor number: 1024
lock engine: pthread robust mutexes
thunder lock: disabled (you can enable it with --thunder-lock)
uwsgi socket 0 inherited UNIX address /run/uwsgi/getws.sock fd 3
Python version: 3.5.2 (default, Sep 14 2016, 11:28:32)  [GCC 6.2.1 20160901 (Red Hat 6.2.1-1)]
PEP 405 virtualenv detected: /ws/.pyvenv/main
Set PythonHome to /ws/.pyvenv/main
Python main interpreter initialized at 0x1842670
python threads support enabled
your server socket listen backlog is limited to 100 connections
your mercy for graceful operations on workers is 60 seconds
mapped 145536 bytes (142 KB) for 1 cores
*** Operational MODE: single process ***
added /ws/pycms.ws/src/ to pythonpath.
added /ws/.pyvenv/main/lib/python3.6/site-packages/ to pythonpath.
init123
WSGI app 0 (mountpoint='') ready in 0 seconds on interpreter 0x1842670 pid: 6440 (default app)
*** uWSGI is running in multiple interpreter mode ***
gracefully (RE)spawned uWSGI master process (pid: 6440)
spawned uWSGI worker 1 (pid: 6456, cores: 1)

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

from functools import update_wrapper


def setupmethod(wrapped):
    def wrapper(*args, **kwargs):
        return wrapped(*args, **kwargs)
    return update_wrapper(wrapper, wrapped)


@setupmethod
def testwrap(f):
    return f


@testwrap
def test():
    """Closes the database again at the end of the request."""
    print('test')

print(test().__doc__)

#!/usr/bin/python
# -*- coding:utf-8 -*-

from select import select
from threading import Thread
import time, struct, socket, hashlib, base64, sys, signal

MAGIC_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
TEXT = 0x01
BINARY = 0x02
 
class WebSocket(object):
 
    handshake = (
        "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
        "Upgrade: WebSocket\r\n"
        "Connection: Upgrade\r\n"
        "Sec-WebSocket-Accept: %(key)s\r\n"
        "\r\n"
    )
 
    def __init__(self, client, server):
        self.client = client
        self.server = server
        self.handshaken = False
        self.header = ""
 
    def feed(self, data):
        if not self.handshaken:
            self.header += data
            if self.header.find('\r\n\r\n') != -1:
                parts = self.header.split('\r\n\r\n', 1)
                self.header = parts[0]
                if self.dohandshake(self.header, parts[1]):
                    self.handshaken = True
        else:
            recv = self.decodeCharArray(data)
            self.onmessage(''.join(recv).strip())
 
    def sendMessage(self, s):
        message = ""
        b1 = 0x80
 
        if type(s) == unicode:
            b1 |= TEXT
            payload = s.encode("UTF8")
        elif type(s) == str:
            b1 |= TEXT
            payload = s
 
        message += chr(b1)
 
        b2 = 0
        
        length = len(payload)
        
        if length < 126:
            b2 |= length
            message += chr(b2)
        elif length < (2 ** 16) - 1:
            b2 |= 126
            message += chr(b2)
            l = struct.pack(">H", length)
            message += l
        else:
            l = struct.pack(">Q", length)
            b2 |= 127
            message += chr(b2)
            message += l
 
        message += payload
 
        self.client.send(str(message))
 
    def decodeCharArray(self, stringStreamIn):
        byteArray = [ord(character) for character in stringStreamIn]
        datalength = byteArray[1] & 127
        indexFirstMask = 2
 
        if datalength == 126:
            indexFirstMask = 4
        elif datalength == 127:
            indexFirstMask = 10
 
        masks = [m for m in byteArray[indexFirstMask : indexFirstMask+4]]
        indexFirstDataByte = indexFirstMask + 4
        
        decodedChars = []
        i = indexFirstDataByte
        j = 0
        
        while i < len(byteArray):
            decodedChars.append( chr(byteArray[i] ^ masks[j % 4]) )
            i += 1
            j += 1
 
        return decodedChars
 
    def dohandshake(self, header, key=None):
        handshake = self.handshake
        
        for line in header.split('\r\n')[1:]:
            name, value = line.split(': ', 1)
            
            if name.lower() == "sec-websocket-key":
                combined = value + MAGIC_GUID
                key = base64.b64encode(hashlib.sha1(combined).digest())
                
                handshake = handshake % { 'key' : key }
 
        self.client.send(handshake)
        return True
 
    def onmessage(self, data):
        self.sendMessage(data.upper());
 
    def send(self, data):
        self.client.send(chr(0) + data + chr(255))
 
    def close(self):
        self.client.close()
 

class WebSocketServer(object):
 
    def __init__(self, bind, port, cls):
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.socket.bind((bind, port))
        self.bind = bind
        self.port = port
        self.cls = cls
        self.connections = {}
        self.listeners = [self.socket]
 
    def listen(self, backlog=5):
 
        self.socket.listen(backlog)
 
        self.running = True
        while self.running:
        
            rList, wList, xList = select(self.listeners, [], self.listeners, 1)
            for ready in rList:
                if ready == self.socket:
                    client, address = self.socket.accept()
                    fileno = client.fileno()
                    self.listeners.append(fileno)
                    self.connections[fileno] = self.cls(client, self)
                else:
                    client = self.connections[ready].client
                    data = client.recv(4096)
                    fileno = client.fileno()
                    if data:
                        self.connections[fileno].feed(data)
                    else:
                        self.connections[fileno].close()
                        del self.connections[fileno]
                        self.listeners.remove(ready)
            
            for failed in xList:
                if failed == self.socket:
                    for fileno, conn in self.connections:
                        conn.close()
                    self.running = False
 
if __name__ == "__main__":
    server = WebSocketServer("", 8000, WebSocket)
    server_thread = Thread(target=server.listen, args=[5])
    server_thread.start()
 
    def signal_handler(signal, frame):
        server.running = False
        sys.exit()
    signal.signal(signal.SIGINT, signal_handler)
 
    while True:
        time.sleep(100)