def fork_happened2():
    if uwsgi.i_am_the_spooler():
        return
    print("worker %d is waiting for signal 100..." % uwsgi.worker_id())
    uwsgi.signal_wait(100)
    print("worker %d received signal %d" % (uwsgi.worker_id(), uwsgi.signal_received()))
    print("fork() has been called [2] wid: %d" % uwsgi.worker_id())

def a_post_fork_thread():
    while True:
        time.sleep(3)
        if uwsgi.i_am_the_spooler():
            print("Hello from a thread in the spooler")
        else:
            print("Hello from a thread in worker %d" % uwsgi.worker_id())

 def __init__(self):
     self.last_msg = None
     self.arena = "arena{}".format(uwsgi.worker_id())
     self.redis = redis.StrictRedis()
     self.channel = self.redis.pubsub()
     self.channel.subscribe(self.arena)
     self.redis_fd = self.channel.connection._sock.fileno()

def index():
    import uwsgi
    message = 'This is a notification from worker %d' % uwsgi.worker_id()
    db.session.execute(fawn.notify('ws', message))
    db.session.commit()

    return """
    <script>
        var s = new WebSocket("ws://" + location.host + "/ws/" + (Math.random() * 1000 << 1));
        s.onopen = e => document.body.innerHTML += 'Socket opened' + '<br>'
        s.onmessage = e => document.body.innerHTML += e.data + '<br>'
        s.onerror = e => document.body.innerHTML += 'Error <br>'
        s.onclose = e => document.body.innerHTML += 'connection closed' + '<br>'
    </script>
    Page rendered on worker %d <br>
    """ % uwsgi.worker_id()

 def instance_id(self):
     if not self._is_mule:
         instance_id = uwsgi.worker_id()
     elif self._farm_name:
         return self._mule_index_in_farm(self._farm_name) + 1
     else:
         instance_id = uwsgi.mule_id()
     return instance_id

def application(env, start_response):

    start_response('200 Ok', [('Content-Type', 'text/html')])

    yield "I am the worker %d<br/>" % uwsgi.worker_id()

    grunt = uwsgi.grunt()

    if grunt is None:
        print "worker %d detached" % uwsgi.worker_id()
    else:
        yield "And now i am the grunt with a fix worker id of %d<br/>" % uwsgi.worker_id()
        time.sleep(2)
        yield "Now, i will start a very slow task...<br/>"
        for i in xrange(1, 10):
            yield "waiting for %d seconds<br/>" % i
            time.sleep(i)

def spawn_consumers():
    global q
    q = Queue.Queue()
    for i in range(CONSUMERS):
        t = Thread(target=consumer,args=(q,))
        t.daemon = True
        t.start()
        print("consumer %d on worker %d started" % (i, uwsgi.worker_id()))

def application(environ, start_response):

    gevent.sleep()
    start_response('200 OK', [('Content-Type', 'text/html')])
    yield "sleeping for 3 seconds...<br/>"
    gevent.sleep(3)
    yield "done<br/>"
    gevent.spawn(microtask, uwsgi.worker_id())
    yield "microtask started<br/>"

    def __init__(self):
        ServiceBase.__init__(self)
        ProfileMixin.__init__(self)
        DispatcherMixin_CRR.__init__(self)

        if not uwsgi.cache_exists('Service2Counter'):
            uwsgi.cache_set('Service2Counter', '0')
        if not uwsgi.cache_exists('Service2Timer'):
            uwsgi.cache_set('Service2Timer', '0')
        print uwsgi.queue_size
        gevent.spawn(microtask, uwsgi.worker_id())
        print 'after gevent.spawn'

def spawn_on_socket(fd):
    worker_id = uwsgi.worker_id()
    application = make_app(debug=options.debug)
    server = HTTPServer(application, xheaders=True, max_body_size=options.max_body_size)
    sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM)
    server.add_sockets([sock])

    if options.prometheus_port:
        prometheus_port = options.prometheus_port + worker_id
        uwsgi.log('starting prometheus server on port %d' % prometheus_port)
        start_http_server(prometheus_port)
    uwsgi.log('tornado plumber reporting for duty on uWSGI worker %s' % worker_id)

 def facts(self):
     facts = super(UWSGIApplicationStack, self).facts
     if not self._is_mule:
         facts.update({
             'pool_name': 'web',
             'server_id': uwsgi.worker_id(),
         })
     else:
         facts.update({
             'pool_name': self._farm_name,
             'server_id': uwsgi.mule_id(),
         })
     facts['instance_id'] = self.instance_id
     return facts

def set_uwsgi_proc_name():
    build_dir = os.path.basename(project_root)
    try:
        deploy_tag = open(os.path.join(project_root, '.DEPLOY_TAG')).read().strip()
    except IOError:
        deploy_tag = '?'

    os.environ['DEPLOY_TAG'] = deploy_tag

    uwsgi.setprocname("uwsgi worker %(worker_id)d <%(build)s> [%(tag)s]" % {
        'worker_id': uwsgi.worker_id(),
        'build': build_dir,
        'tag': deploy_tag,
    })

def application(environ, start_response):
    global _application

    uwsgi.set_logvar('worker_id', str(uwsgi.worker_id()))

    if not os.environ.get('DJANGO_SETTINGS_MODULE'):
        os.environ['DJANGO_SETTINGS_MODULE'] = environ.get('DJANGO_SETTINGS_MODULE', 'settings')

    if _application is None:
        try:
            from django.core.wsgi import get_wsgi_application
        except ImportError:
            import django.core.handlers.wsgi
            _application = django.core.handlers.wsgi.WSGIHandler()
        else:
            _application = get_wsgi_application()

    return _application(environ, start_response)

def index():
    return """
    <script>
        var sockets = [];
        function handle_socket(i) {
            var s = new WebSocket("ws://" + location.host + "/ws/" + i);
            s.onopen = e => document.body.innerHTML += i + ' opened  <br>'
            s.onmessage = e => document.body.innerHTML += e.data + ' (' + i + ') <br>'
            s.onerror = e => document.body.innerHTML += 'Error (' + i + ')<br>'
            s.onclose = e => document.body.innerHTML += 'Socket closed (' + i + ')<br>'
            return s;
        }
        document.addEventListener('DOMContentLoaded', function () {
            for (var i = 0; i < 10; i++) {
                sockets.push(handle_socket(i))
            }
        });
    </script>
    Page rendered on worker %d <br>
    """ % uwsgi.worker_id()

    def __init__(self, game, name, avatar, fd, x, y, r, color, speed=15):
        self.game = game
        self.name = name
        self.avatar = avatar
        self.fd = fd

        self.arena_object = ArenaObject(x, y, r, speed)

        self.attack = 0
        self.energy = 100.0

        self.arena = "arena{}".format(uwsgi.worker_id())
        self.redis = redis.StrictRedis()
        self.channel = self.redis.pubsub()
        self.channel.subscribe(self.arena)
        self.redis_fd = self.channel.connection._sock.fileno()

        self.cmd = None
        self.attack_cmd = None
        self.bullet = Bullet(self.game, self)
        self.color = color

def init():
    schema = Schema(title=TEXT(stored=True),
                    path=TEXT(stored=True),
                    content=TEXT)

    rel = dirname(__file__)
    index_name = 'index'
    if no_uwsgi:
        # attenzione: il restart provochera' la creazione di nuove cartelle
        # ogni volta...
        index_name += '{0}'.format(os.getpid())
    else:
        index_name += '{0}'.format(uwsgi.worker_id())

    index_dir = join(rel, index_name)

    if not exists(index_dir):
        mkdir(index_dir)

    logging.debug('create lyrics index')

    global ix
    ix = create_in(index_dir, schema)

    writer = ix.writer()

    lyrics_dir = join(rel, 'items')

    onlyfiles = [f for f in listdir(lyrics_dir) if isfile(join(lyrics_dir, f))]
    for file in onlyfiles:
        with open(join(lyrics_dir, file), encoding="utf-8") as f:
            cnt = f.read()
            link = cnt.splitlines()[0]

            writer.add_document(
                    title=file,
                    content=cnt,
                    path=link)

    writer.commit()

    def __init__(self, game, name, avatar, fd, x, y, z, r, color, scale=5, speed=15):
        self.size_x = 30 
        self.size_y = 35
        self.size_z = 45 
        super(Player, self).__init__(game, 90.0, self.size_x, self.size_y, self.size_z, x, y, z, r)
        self.name = name
        self.avatar = avatar
        self.fd = fd

        self.last_msg = None

        self.scale = scale

        # self.attack = 0
        self.energy = 100.0
        self.arena = "arena{}".format(uwsgi.worker_id())
        self.redis = redis.StrictRedis()
        self.channel = self.redis.pubsub()
        self.channel.subscribe(self.arena)
        self.redis_fd = self.channel.connection._sock.fileno()

        self.cmd = None
        # self.bullet = Bullet(self.game, self)
        self.color = color

 def __call__(self, *args, **kwargs):
     if self.f:
         if self.wid > 0 and self.wid != uwsgi.worker_id():
             return
         return self.f()
     self.f = args[0]

def application(env, start_response):
    try:
        uwsgi.mule_msg(env['REQUEST_URI'], 1)
    except:
        pass

    req = uwsgi.workers()[uwsgi.worker_id()-1]['requests']

    uwsgi.setprocname("worker %d managed %d requests" % (uwsgi.worker_id(), req))

    try:
        gc.collect(2)
    except:
        pass
    if DEBUG:
        print(env['wsgi.input'].fileno())

    if env['PATH_INFO'] in routes:
        return routes[env['PATH_INFO']](env, start_response)


    if DEBUG:
        print(env['wsgi.input'].fileno())

    try:
        gc.collect(2)
    except:
        pass

    if DEBUG:
        print(len(gc.get_objects()))

    workers = ''
    for w in uwsgi.workers():
        apps = '<table border="1"><tr><th>id</th><th>mountpoint</th><th>startup time</th><th>requests</th></tr>'
        for app in w['apps']:
            apps += '<tr><td>%d</td><td>%s</td><td>%d</td><td>%d</td></tr>' % (app['id'], app['mountpoint'], app['startup_time'], app['requests']) 
        apps += '</table>'
        workers += """
<tr>
<td>%d</td><td>%d</td><td>%s</td><td>%d</td><td>%d</td><td>%d</td><td>%s</td>
</tr>
        """ % (w['id'], w['pid'], w['status'], w['running_time']/1000, w['avg_rt']/1000, w['tx'], apps)

    output = """
<img src="/logo"/> version %s running on %s (remote user: %s)<br/>
<hr size="1"/>

Configuration<br/>
<iframe src="/config"></iframe><br/>

<br/>

Dynamic options<br/>
<iframe src="/options"></iframe><br/>

<br/>
Workers and applications<br/>
<table border="1">
<tr>
<th>wid</th><th>pid</th><th>status</th><th>running time</th><th>average</th><th>tx</th><th>apps</th>
</tr>
%s
</table>

    """ % (uwsgi.version, uwsgi.hostname, env.get('REMOTE_USER','None'), workers)

    start_response('200 OK', [('Content-Type', 'text/html'), ('Content-Length', str(len(output)) )])

    #return bytes(output.encode('latin1'))
    return output

def setprocname():
    if uwsgi.worker_id() > 0:
        uwsgi.setprocname("i am the worker %d" % uwsgi.worker_id())