Esempio n. 1
0
def decorate (
        listen, inactive, local, private, public, resolved=dns_PTR_resolved
        ):
        ip = listen.addr[0]
        concurrency_50 = async_loop.concurrency / 2
        if ip.startswith ('127.'):
                async_server.accept_named (listen, min (
                        max (local, 1), concurrency_50
                        ))
        else:
                if ip.startswith ('192.168.') or ip.startswith ('10.'):
                        async_server.accept_named (listen, min (
                                max (private, 1), concurrency_50
                                ))
                else:
                        async_server.accept_named (listen, min (
                                max (public, 2), concurrency_50
                                ))
                async_server.inactive (listen, min (inactive, 3.0))
                resolved (listen)
        return listen


# The ultimate convenience: decorate TCP/IP servers relevantly according
# to its runtime environment (development/production) and the degree of
# privacy of its network address: personal , private or public.
#
# Wether it's an HTTP or an SQL server, enforcing resolution and connection
# limits is an aspect of the same application: TCP/IP access control. This
# is one obvious way to do it right, conveniently provided as an extensible
# function (you can replace the default resolution decorator). 

        
Esempio n. 2
0
def decorate(listen,
             inactive,
             local,
             private,
             public,
             resolved=dns_PTR_resolved):
    ip = listen.addr[0]
    concurrency_50 = async_loop.concurrency / 2
    if ip.startswith('127.'):
        async_server.accept_named(listen, min(max(local, 1), concurrency_50))
    else:
        if ip.startswith('192.168.') or ip.startswith('10.'):
            async_server.accept_named(listen,
                                      min(max(private, 1), concurrency_50))
        else:
            async_server.accept_named(listen,
                                      min(max(public, 2), concurrency_50))
        async_server.inactive(listen, min(inactive, 3.0))
        resolved(listen)
    return listen
    async_loop, finalization,
    async_net, async_chat, async_server
    )
        
loglines = async_server.Listen (
    async_chat.Dispatcher, ('127.0.0.1', 1234),
    6.0, 5, socket.AF_INET 
    )
async_loop.catch (loglines.server_shutdown)
del loglines
    
lognet = async_server.Listen (
    async_net.Dispatcher, ('127.0.0.1', 2345),
    6.0, 5, socket.AF_INET 
    )
async_server.accept_named (lognet, 512)
async_server.inactive (lognet, 6)
async_loop.catch (lognet.server_shutdown)
del lognet
    
loglines = async_server.Listen (
    async_chat.Dispatcher, ('127.0.0.1', 3456),
    3.0, 5, socket.AF_INET 
    )
loglines.server_resolved = (lambda addr: addr[0])
async_server.accept_named (loglines, 2)
async_server.rationed (loglines, 6.0, 1<<14, 1<<16)
async_loop.catch (loglines.server_shutdown)
del loglines

async_loop.dispatch ()
import socket

from allegra import (async_loop, finalization, async_net, async_chat,
                     async_server)

loglines = async_server.Listen(async_chat.Dispatcher, ('127.0.0.1', 1234), 6.0,
                               5, socket.AF_INET)
async_loop.catch(loglines.server_shutdown)
del loglines

lognet = async_server.Listen(async_net.Dispatcher, ('127.0.0.1', 2345), 6.0, 5,
                             socket.AF_INET)
async_server.accept_named(lognet, 512)
async_server.inactive(lognet, 6)
async_loop.catch(lognet.server_shutdown)
del lognet

loglines = async_server.Listen(async_chat.Dispatcher, ('127.0.0.1', 3456), 3.0,
                               5, socket.AF_INET)
loglines.server_resolved = (lambda addr: addr[0])
async_server.accept_named(loglines, 2)
async_server.rationed(loglines, 6.0, 1 << 14, 1 << 16)
async_loop.catch(loglines.server_shutdown)
del loglines

async_loop.dispatch()
finalization.collect()