def serve(address="0.0.0.0",port=24414):
    global config, conn_sock, ifname, tunfd
    name, public_key, secret_key = load_identity()
    if name is not None:
        print("Your identity is:")
        print(name + " " + get_fingerprint(public_key))
        print("Verify this fingerprint is valid when connecting")
    else:
        name, public_key, secret_key = new_key_interface()
    config = configparser.RawConfigParser()
    config.read("netshrink.cfg")
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    conn_sock = sock
    sock.bind((address,port))
    loop = pyev.default_loop()
    io = pyev.Io(sock, pyev.EV_READ, loop, serve_cb)
    io.start()
    sigint = pyev.Signal(2, loop, sigint_cb)
    sigint.start()
    print("Starting tun interface...")
    iface_name = config.get("netshrink", "iface_name").encode("utf8")
    #start the tun interface
    try:
        tunfd = os.open("/dev/net/tun", os.O_RDWR)
        ifname = ioctl(tunfd, TUNSETIFF,
                       struct.pack("16sH", iface_name, IFF_TUN))
    except IOError:
        print("You do not have permissions to create a tunnel interface.")
        sys.exit(1)
    ifname = ifname[:ifname.find(b'\0')]
    tunio = pyev.Io(tunfd, pyev.EV_READ, loop, tun_cb)
    tunio.start()
    print("Listening for new connections")
    loop.start()

    def __init__(self, start_server_ip="127.0.0.1", start_server_port=5000, num_server_workers=8):

        self.start_server_ip = start_server_ip
        self.start_server_port = start_server_port
        self.num_server_workers = num_server_workers
        self.listen_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.listen_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.listen_sock.bind((start_server_ip, start_server_port))
        self.listen_sock.setblocking(0)
        self.listen_sock.settimeout(1)
        self.address = self.listen_sock.getsockname()

        self.worker_procs = []
        self.worker_queues = []

        for i in range(num_server_workers):

            # Create a pair of (inQ,outQ) for IPC with the worker

            worker_in_q = multiprocessing.Queue()
            worker_out_q = multiprocessing.Queue()

            self.worker_queues.append((worker_in_q, worker_out_q))

            # Create the worker process object

            worker_proc = ServerWorker("SW." + str(i + 1), worker_in_q, worker_out_q)

            worker_proc.daemon = True
            self.worker_procs.append(worker_proc)

            # Start the worker process

            worker_proc.start()

        # By now the server workers have been spawned

        # Setup the default Pyev loop in the master

        self.loop = pyev.default_loop(flags=pyev.recommended_backends())

        # Prepare signal , out Q and connection watchers

        self.sig_watchers = [pyev.Signal(sig, self.loop, self.signal_cb) for sig in STOPSIGNALS]

        self.q_watchers = [
            pyev.Io(
                fd=worker.out_q._reader.fileno(),
                events=pyev.EV_READ,
                loop=self.loop,
                callback=self.out_q_cb,
                data=worker,
            )
            for worker in self.worker_procs
        ]

        self.socket_watchers = [
            pyev.Io(fd=self.listen_sock.fileno(), events=pyev.EV_READ, loop=self.loop, callback=self.io_cb)
        ]
        self.next_worker = 0

def main():
    path = "adder_service"
    name = "adder"

    loop = pyev.default_loop()

    sigwatcher = pyev.Signal(signal.SIGINT, loop, lambda watcher, events: watcher.loop.stop(pyev.EVBREAK_ALL))
    sigwatcher.start()

    service = spawn(Adder, loop, name, path)
    sproxy = ServiceProxy(loop, path)

    sproxy.connect()

    clients = []
    proxies = []

    # to push the server further (to see how fast it will really go...)
    # just add more clients!
    for x in range(30):
        bpath = "adder_bench_%i" % x
        client = spawn(AdderBench, loop, bpath, bpath, path)
        bproxy = ServiceProxy(loop, "adder_bench_1")
        bproxy.connect()
        clients.append(client)
        proxies.append(bproxy)

    loop.start()

    def __init__(self, address=("",8888), console=("",9876)):

        # init proxy socket
        self.sock = socket.socket()
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.sock.bind(address)
        self.sock.setblocking(0)
        self.proxyaddress = self.sock.getsockname()
 
        # init console socket
        self.console = socket.socket()
        self.console.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.console.bind(console)
        self.console.setblocking(0)
        self.consoleaddress = self.console.getsockname()
 
        self.loop = pyev.default_loop()
        self.watchers = [pyev.Signal(sig, self.loop, self.signal_cb)
                         for sig in STOPSIGNALS]
        self.watchers.append(pyev.Io(self.sock._sock, pyev.EV_READ, self.loop,
                                    self.io_cb))

        self.watchers.append(pyev.Io(self.console._sock, pyev.EV_READ, self.loop,
                                     self.console_cb))

        self.connection_count = 0
        self.conns = {}

    def __init__(
        self,
        parameters=None,
        on_open_callback=None,
        on_open_error_callback=None,
        on_close_callback=None,
        stop_ioloop_on_close=False,
        custom_ioloop=None,
        on_signal_callback=None,
    ):
        """Create a new instance of the LibevConnection class, connecting
        to RabbitMQ automatically

        :param pika.connection.Parameters parameters: Connection parameters
        :param on_open_callback: The method to call when the connection is open
        :type on_open_callback: method
        :param on_open_error_callback: Method to call if the connection cannot
                                       be opened
        :type on_open_error_callback: method
        :param bool stop_ioloop_on_close: Call ioloop.stop() if disconnected
        :param custom_ioloop: Override using the default IOLoop in libev
        :param on_signal_callback: Method to call if SIGINT or SIGTERM occur
        :type on_signal_callback: method

        """
        self.ioloop = custom_ioloop or pyev.default_loop()
        self._on_signal_callback = on_signal_callback
        self._io_watcher = None
        self._active_timers = {}
        self._stopped_timers = deque()

        super(LibevConnection, self).__init__(
            parameters, on_open_callback, on_open_error_callback, on_close_callback, self.ioloop, stop_ioloop_on_close
        )

    def __init__(self, 
            start_client_ip="127.0.0.1",
            start_client_port=10000,
            end_client_port=60000,
            num_cnxn_per_client=10,
            num_cnxn_per_sec=1,
            start_server_ip="127.0.0.1",
            start_server_port=5000,
            num_client_workers=1):

        self.worker_procs = []
        self.worker_queues = []

        client_ip = start_client_ip
        server_ip = start_server_ip

        for i in range(num_client_workers):

            # Create a pair of (inQ,outQ) for IPC with the worker
            worker_in_q = multiprocessing.Queue()
            worker_out_q = multiprocessing.Queue()

            self.worker_queues.append((worker_in_q,worker_out_q))

            # Create the worker process object
            worker_proc = ClientWorker("CW."+str(i+1), 
                                       worker_in_q,
                                       worker_out_q,
                                       client_ip,
                                       start_client_port,
                                       end_client_port,
                                       num_cnxn_per_client,
                                       num_cnxn_per_sec,
                                       server_ip,
                                       start_server_port 
                                       )

            worker_proc.daemon = True
            self.worker_procs.append(worker_proc)
        
            # Start the worker process
            worker_proc.start()
    
        # By now the client workers have been spawned

        # Setup the default Pyev loop in the master 
        self.loop = pyev.default_loop(flags=pyev.EVBACKEND_EPOLL)

        # Prepare signal and out Q watchers
        self.sig_watchers = [pyev.Signal(sig, self.loop, self.signal_cb)
                              for sig in STOPSIGNALS]

        self.q_watchers = [pyev.Io(fd=worker.out_q._reader.fileno(), 
                                  events=pyev.EV_READ,
                                  loop=self.loop, 
                                  callback=self.out_q_cb,
                                  data=worker)
                            for worker in self.worker_procs]

 def __init__(self, address):
         self.sock = socket.socket()
         self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         self.sock.bind(address)
         self.sock.setblocking(0)
         self.address = self.sock.getsockname()
         self.loop = pyev.default_loop()
         self.watchers = [pyev.Signal(sig, self.loop, self.signal_cb) for sig in STOPSIGNALS]
         self.watchers.append(pyev.Io(self.sock._sock, pyev.EV_READ, self.loop, self.io_cb))
         self.conns = weakref.WeakValueDictionary()

    def serve(self, sock, nevents=None):
        loop = pyev.default_loop()

        self.clients = {}
        main = pyev.Io(sock, pyev.EV_READ, loop, self.accept, data=sock)
        main.start()

        sigint = pyev.Signal(signal.SIGINT, loop, self.sigint, data=[main])
        sigint.start()

        loop.loop()

 def __init__(self,address):
     self.address = address
     self.sock = socket.socket()
     self.sock.bind(address)
     self.sock.setblocking(0)
     self.sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEPORT,1)
     #self.address = self.sock.getsockname()
     self.loop = pyev.default_loop()
     self.watchers = [pyev.Signal(sig, self.loop, self.signal_cb)\
                 for sig in STOPSIGNAL]
     self.watchers.append(pyev.Io(self.sock,pyev.EV_READ,self.loop, self.io_cb))

        def __init__(self, logger=None):
            #self._loop = pyev.default_loop(io_interval=timeout/1000.0, timeout_interval=timeout/1000.0)
            #self._loop = pyev.default_loop(timeout_interval=timeout)
            self._loop = pyev.default_loop()
            self._timer = pyev.Timer(0.01, 0, self._loop, self._timer_callback)
            self._timeout = 100
#            print self._loop.backend, pyev.EVBACKEND_EPOLL
            self._watchers = dict()  # key is fd
            self._empty = []
            self.logger = logger
            self._in = pyev.EV_READ
            self._out = pyev.EV_WRITE

    def __init__(self, hooks):
        self.sequenceid = None
        self._need_synch = False
        self.indata = None
        self.outdata = ''

        self.hooks = hooks

        loop = pyev.default_loop()
        self.watcher = pyev.Io(self._file.fileno(), pyev.EV_READ, loop,
                self.io, self)
        self.watcher.start()

def main():
    loop = pyev.default_loop()
    
    signal_handler = whizzer.signal_handler(loop)
    signal_handler.start()
    
    factory = HTTPProtocolFactory()
    server = whizzer.TcpServer(loop, factory, "127.0.0.1", 2000, 256)

    signal_handler.start()
    server.start()

    loop.loop()

 def __init__(self, bind_host, handler):
     register.handler = handler
     self.bind_host = bind_host
     self.connections = {}
     self.loop = pyev.default_loop()
     self.watchers = [pyev.Signal(sig, self.loop, self.signal_cb) for sig in STOPSIGNALS]
     # create the socket and bind
     self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     self.sock.bind(bind_host)
     self.sock.setblocking(0)
     # create the watcher that listens for new connections
     self.listen_watcher = pyev.Io(self.sock, pyev.EV_READ, self.loop, self.io_cb)

    def init(self, args):

        self.current = 0


        debug('init')

        l = pyev.default_loop()
        self.timer = pyev.Timer(30.0, 30.0, l, self.do_timer)
        self.timer.start()

        return {
            'output': self.do_output,
        }

def connect(address, port=24414):
    global config, connection_map
    name, public_key, secret_key = load_identity()
    if name is not None:
        print("Your identity is:")
        print(name + " " + get_fingerprint(public_key))
        print("Verify this fingerprint is valid when connecting")
    else:
        name, public_key, secret_key = new_key_interface()
    config = configparser.RawConfigParser()
    config.read("netshrink.cfg")
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    loop = pyev.default_loop()
    connection_map[0] = Connection(sock, (address, port))

def start_periodic_tasks():

    loop = pyev.default_loop(pyev.EVFLAG_FORKCHECK)
    def sig_cb(watcher, revents):
        loop.stop(pyev.EVBREAK_ALL)
        for t, l in _tasks:
            l.stop(pyev.EVBREAK_ALL)
            # t.join()
    for t,l in _tasks:
        t.start()
    # now wait for events to arrive
    sig = loop.signal(signal.SIGINT, sig_cb)
    sig.start()
    loop.start()

def main():
    loop = pyev.default_loop()

    signal_handler = whizzer.signal_handler(loop)

    factory = whizzer.ProtocolFactory()
    factory.protocol = EchoClientProtocol

    clients = []
    # number of parallel clients
    for x in range(0, 2):
        clients.append(EchoClient(x, loop, factory))

    signal_handler.start()
    loop.loop()

 def run(self):
     """Start the bot and its event loop"""
     self.loop = pyev.default_loop()
     self.loop.debug = self.app.debug
     delay = self.app.config['IRC_RECONNECT_DELAY']
     self._reconnect_tmr = pyev.Timer(delay, delay, self.loop, self._reconnect_cb)
     for name in self.app.config['IRC_MODULES']:
         self.load_module(name)
     self.logger.info('Starting event loop')
     self._connect()
     self._sigwatchers = [pyev.Signal(sig, self.loop, self._sig_cb)
         for sig in STOPSIGNALS.iterkeys()]
     for watcher in self._sigwatchers:
         watcher.start()
     self.loop.start()

def main():
    loop = pyev.default_loop()
    
    signal_handler = whizzer.signal_handler(loop)
    signal_handler.start()
    
    factory = EchoProtocolFactory()
    server = whizzer.TcpServer(loop, factory, "127.0.0.1", 2000, 256)
    stats = EchoStatistics(loop, factory)

    signal_handler.start()
    server.start()
    stats.start()

    loop.loop()

	def __init__(self, config):
		logger.debug('hpfeedhandler init')
		self.client = hpclient(config['server'], int(config['port']), config['ident'], config['secret'])
		ihandler.__init__(self, '*')

		self.dynip_resolve = config.get('dynip_resolve', '')
		self.dynip_timer = None
		self.ownip = None
		if self.dynip_resolve and 'http' in self.dynip_resolve:
			if pyev == None:
				logger.debug('You are missing the python pyev binding in your dionaea installation.')
			else:
				logger.debug('hpfeedihandler will use dynamic IP resolving!')
				self.loop = pyev.default_loop()
				self.dynip_timer = pyev.Timer(2., 300, self.loop, self._dynip_resolve)
				self.dynip_timer.start()