def server_main(loop, path):
"""Run in the client after the fork."""
loop.fork()
logger.debug('forked function')
sigintwatcher = pyev.Signal(
signal.SIGINT, loop,
lambda watcher, events: logger.info('interrupt ignored'))
sigintwatcher.start()
sigtermwatcher = pyev.Signal(signal.SIGTERM, loop, server_stop)
sigtermwatcher.start()
adder = AdderService()
dispatcher = ObjectDispatch(adder)
pickle_factory = PickleProtocolFactory(dispatcher)
pickle_server = UnixServer(loop, pickle_factory, path)
pickle_server.start()
msgpack_factory = MsgPackProtocolFactory(dispatcher)
msgpack_server = UnixServer(loop, msgpack_factory, path + '_mp')
msgpack_server.start()
logger.debug('running server loop')
import cProfile
cProfile.runctx('loop.loop()', None, {'loop': loop}, 'server_profile')
logger.debug('server unlooped')
def _do_wait(self, timeout):
"""Wait for the deferred to be completed for a period of time
Raises TimeoutError if the wait times out before the future is done.
Raises CancelledError if the future is cancelled before the
timeout is done.
"""
if self._cancelled:
raise CancelledError()
if not self._done:
self._wait = True
self._sigint = pyev.Signal(signal.SIGINT, self.loop,
lambda watcher, events: self._cancel(),
None)
self._sigint.start()
if timeout and timeout > 0.0:
self._timer = pyev.Timer(timeout, 0.0, self.loop,
self._clear_wait, None)
self._timer.start()
while self._wait and not self._done and not self._cancelled:
self.loop.start(pyev.EVRUN_ONCE)
if self._cancelled:
raise CancelledError()
elif not self._done:
raise TimeoutError()
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, datafile, probespath, probe_confs):
self.active = False
self.active_probes = 0
self.probespath = probespath
self.loop = pyev.Loop()
#self.queue = Queue()
# initialize and start a idle watcher
#self.idle_watcher = pyev.Idle(self.loop, self.idle_cb)
#self.idle_watcher.start()
# initialize and start a signal watchers
sigterm_watcher = pyev.Signal(signal.SIGTERM, self.loop,
self.sigterm_cb)
sigterm_watcher.start()
sigint_watcher = pyev.Signal(signal.SIGINT, self.loop, self.sigint_cb)
sigint_watcher.start()
self.loop.data = [sigterm_watcher, sigint_watcher]
#self.loop.data.append(self.idle_watcher)
# initialize storage
logging.info("Init storage...")
self.storage = Storage(datafile)
# read in probes from config
self.probes = []
index = 0
for probe_conf in probe_confs:
self.check_command(probe_conf)
self.check_data_type(probe_conf)
self.check_dummy(probe_conf)
# load filters
self.load_filters(probe_conf)
# load error filters
self.load_error_filters(probe_conf)
p = self.get_probe(index, self.storage, probe_conf, -1)
p.register(self.loop)
self.probes.append(p)
if probe_conf.get("auto_start", False):
self.start_probe(index)
index = index + 1
def __init__(self,
start_server_ip="127.0.0.1",
start_server_port=5000,
num_server_workers=1):
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 __init__(self, iface, essid, bssid, channel, beacon_interval_sec, packet_callback):
self.active = False
self.iface = iface
self.essid = essid
self.bssid = bssid
self.channel = channel
self.beacon_interval_sec = beacon_interval_sec
self.packet_callback = packet_callback
self.start_time_secs = time.time()
self.sc = 0
self.sender = PacketSender(self.iface)
self.beacon_packet = dot11.Dot11(addr1='ff:ff:ff:ff:ff:ff', \
addr2=self.bssid, \
addr3=self.bssid) \
/ dot11.Dot11Beacon(cap='ESS+privacy') \
/ dot11.Dot11Elt(ID='SSID', \
info=self.essid) \
/ dot11.Dot11Elt(ID='DSset', \
info=chr(self.channel)) \
/ dot11.Dot11Elt(ID='Rates', \
info='\x82\x84\x0b\x16') \
/ dot11.Dot11Elt(ID='RSNinfo',
info='\x01\x00\x00\x0f\xac' \
'\x04\x01\x00\x00\x0f' \
'\xac\x04\x01\x00\x00' \
'\x0f\xac\x02\x00\x00')
self.watchers = {
"interval": None,
"timeout": None
}
self.loop = pyev.Loop()
# initialize and start a signal watchers
sigterm_watcher = pyev.Signal(signal.SIGTERM, self.loop, self.sigterm_cb)
sigterm_watcher.start()
sigint_watcher = pyev.Signal(signal.SIGINT, self.loop, self.sigint_cb)
sigint_watcher.start()
self.loop.data = [sigterm_watcher, sigint_watcher]
self.sniff_thread = Thread(target=self.sniff,
kwargs=dict(),
name='sniff-thread')
self.sniff_thread.setDaemon(True)
def loop(l=default_loop): sigint_watcher = pyev.Signal(signal.SIGINT, default_loop, _sigint_cb) sigint_watcher.start() try: l.start() except OSError, e: traceback.print_exc() print 'oserror', e, e.args
def __init__(self, config):
self.active = False
self.config = config
self.watcher = None
self.loop = pyev.Loop()
# initialize and start a signal watchers
sigterm_watcher = pyev.Signal(signal.SIGTERM, self.loop, self.sigterm_cb)
sigterm_watcher.start()
sigint_watcher = pyev.Signal(signal.SIGINT, self.loop, self.sigint_cb)
sigint_watcher.start()
self.loop.data = [sigterm_watcher, sigint_watcher]
# init GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(config['GPIO_in'], GPIO.IN)
GPIO.setup(config['GPIO_out'], GPIO.OUT, initial=GPIO.HIGH)
def __init__(self, dsp_endpoints, event_endpoint, balance_conn_timeout):
'''
Constructor
dsp_endpoints : is a list of tuples(endpoint, qps) where
enpoint is a string like '192.168.10.152:5869'
and qps is the value indicating queries per
second for that enpoint.
balance_conn_timeout : is the time period for rebalancing
available connections.
'''
# list containing tuples in the form
# (endpoint, expected qps, current qps)
self.dest_eps = [[ep[0], ep[1], 0] for ep in dsp_endpoints]
self.event_endpoint = event_endpoint
self.conns = {}
self.awaiting_conns = {}
self.event_conn_queue = []
self.event_conns = {}
self.event_connections = 0
self.keep_alive_resp_waiting = {}
self.balance_conn_to = balance_conn_timeout
self.loop = pyev.default_loop()
self.watchers = [
pyev.Signal(sig, self.loop, self.signal_cb) for sig in STOPSIGNALS
]
self.watchers.append(
pyev.Timer(self.balance_conn_to, self.balance_conn_to, self.loop,
self.balance))
self.watchers.append(
pyev.Timer(CHECK_CONNS_TO, CHECK_CONNS_TO, self.loop,
self.check_established_connections))
self.watchers.append(
pyev.Timer(CHECK_PENDING_TO, CHECK_PENDING_TO, self.loop,
self.check_pending_wins))
if EVENT_CONN_KEEP_ALIVE_TO:
self.watchers.append(
pyev.Timer(EVENT_CONN_KEEP_ALIVE_TO, EVENT_CONN_KEEP_ALIVE_TO,
self.loop, self.send_keep_alives))
self.current_connections = 0
self.request_fact = RTBRequestFactory(TEMPLATE_FILENAME)
self.adserver = AdServer(self.loop)
self.request_fact.initialize()
self.request_fact.set_parameter_plug(PARAMETER_PLUGIN, self.adserver)
if PLUGIN_DO_TO:
self.watchers.append(
pyev.Timer(PLUGIN_DO_TO, PLUGIN_DO_TO, self.loop,
self.request_fact.plugin_instance.do))
self.pending_wins = []
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 server_run(sock, service, handler):
"""运行thrift server"""
thread_info = ThreadInfo(sock, service, handler)
main_loop = pyev.Loop(0, data=thread_info)
io_watcher = pyev.Io(sock, pyev.EV_READ, main_loop, on_request)
io_watcher.start()
stop_watcher = pyev.Signal(signal.SIGINT, main_loop, on_stop, priority=5)
stop_watcher.start()
main_loop.start()
def __init__(self, loop, factory):
self.loop = loop
self.factory = factory
self.connector = None
self.connection = None
self.connect_deferred = None
self.sigint_watcher = pyev.Signal(signal.SIGINT, self.loop,
self._interrupt)
self.sigint_watcher.start()
self.connector = None
self.sock = None
self.addr = None
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 _prepare(self):
"""Initialize server components which ``stop()`` may render invalid.
:raises: socket.error on failure to create, or bind on socket.
"""
self._sock = socket.socket()
self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._sock.setblocking(0)
self._sock.bind(self._address)
self._watchers = [
pyev.Signal(sig, self._loop, self._signal_handler)
for sig in self._HANDLED_SIGNALS
]
self._watchers.append(
pyev.Io(self._sock, pyev.EV_READ, self._loop,
self._socket_handler))
self._worker_thread = self._thread_factory(self._tasks,
self._shutdown_event,
self._hup_event)
def __init__(self, loop, factory, sock, address):
"""Socket server listens on a given socket for incoming connections.
When a new connection is available it accepts it and creates a new
Connection and Protocol to handle reading and writting data.
loop -- pyev loop
factory -- protocol factory (object with build(loop) method that returns a protocol object)
sock -- socket to listen on
"""
self.loop = loop
self.factory = factory
self.sock = sock
self.address = address
self.connections = set()
self._closing = False
self._shutdown = False
self.interrupt_watcher = pyev.Signal(signal.SIGINT, self.loop,
self._interrupt)
self.interrupt_watcher.start()
self.read_watcher = pyev.Io(self.sock, pyev.EV_READ, self.loop,
self._readable)
def main():
path = 'adder_socket'
loop = pyev.default_loop()
sigwatcher = pyev.Signal(
signal.SIGINT, loop,
lambda watcher, events: watcher.loop.unloop(pyev.EVUNLOOP_ALL))
sigwatcher.start()
p = Process(loop, server_main, loop, 'adder_socket')
p.start()
pickle_factory = PickleProtocolFactory()
pickle_client = UnixClient(loop, pickle_factory, path)
retries = 10
while retries:
try:
pickle_client.connect().result()
retries = 0
except Exception as e:
time.sleep(0.1)
retries -= 1
proxy = pickle_factory.proxy(0).result()
start = time.time()
s = 0
for i in range(10000):
s = proxy.call('add', 1, s)
stop = time.time()
logger.info(
'pickle-rpc took {} seconds to perform {} calls, {} calls per second',
stop - start, s, s / (stop - start))
start = time.time()
for i in range(10000):
proxy.notify('add', 1, s)
proxy.call('add', 1, s)
stop = time.time()
logger.info(
'pickle-rpc took {} seconds to perform {} notifications, {} notifies per second',
stop - start, 10000, 10000 / (stop - start))
msgpack_factory = MsgPackProtocolFactory()
msgpack_client = UnixClient(loop, msgpack_factory, path + '_mp')
retries = 10
while retries:
try:
msgpack_client.connect().result()
retries = 0
except Exception as e:
time.sleep(0.1)
retries -= 1
proxy = msgpack_factory.proxy(0).result()
start = time.time()
s = 0
for i in range(10000):
s = proxy.call('add', 1, s)
stop = time.time()
logger.info(
'msgpack-rpc took {} seconds to perform {} calls, {} calls per second',
stop - start, s, s / (stop - start))
start = time.time()
for i in range(10000):
proxy.notify('add', 1, s)
proxy.call('add', 1, s)
stop = time.time()
logger.info(
'msgpack-rpc took {} seconds to perform {} notifications, {} notifies per second',
stop - start, 10000, 10000 / (stop - start))
p.stop()
def sig_cb(watcher, events):
print("got SIGINT")
# optional - stop all watchers
if watcher.data:
print("stopping watchers: {0}".format(watcher.data))
while watcher.data:
watcher.data.pop().stop()
# unloop all nested loop
print("stopping the loop: {0}".format(watcher.loop))
watcher.loop.stop(pyev.EVBREAK_ALL)
def timer_cb(watcher, revents):
watcher.data += 1
print("timer.data: {0}".format(watcher.data))
print("timer.loop.iteration: {0}".format(watcher.loop.iteration))
print("timer.loop.now(): {0}".format(watcher.loop.now()))
if __name__ == "__main__":
loop = pyev.default_loop()
# initialise and start a repeating timer
timer = pyev.Timer(0, 2, loop, timer_cb, data=0)
timer.start()
# initialise and start a Signal watcher
sig = pyev.Signal(signal.SIGINT, loop, sig_cb)
sig.data = [timer, sig] # optional
sig.start()
# now wait for events to arrive
loop.start()
socks = socket_factory.create_socket_listen()
except socket.error, e:
L.fatal(
"It looks like that server is already running: {0}".format(
e))
sys.exit(1)
self.cnssockets.extend(socks)
if len(self.cnssockets) == 0:
L.fatal(
"There is no console socket configured - considering this as fatal error"
)
sys.exit(1)
self.loop = pyev.default_loop()
self.watchers = [
pyev.Signal(sig, self.loop, self.__terminal_signal_cb)
for sig in self.STOPSIGNALS
]
self.watchers.append(
pyev.Signal(signal.SIGHUP, self.loop, self.__restart_signal_cb))
self.watchers.append(pyev.Periodic(0, 1.0, self.loop, self.__tick_cb))
if sys.platform == 'win32':
# There is no pyev.Child watcher on Windows; periodic check is used instead
self.watchers.append(
pyev.Periodic(0, 0.5, self.loop, self.__check_childs_cb))
else:
self.watchers.append(
pyev.Child(0, False, self.loop, self.__child_signal_cb))
for sock in self.cnssockets:
def signal_init(self):
self.sigintwatcher = pyev.Signal(signal.SIGINT, self.loop, self._stop)
self.sigintwatcher.start()
self.sigtermwatcher = pyev.Signal(signal.SIGTERM, self.loop,
self._terminate)
self.sigtermwatcher.start()
class httpfend_app(object):
STOPSIGNALS = [signal.SIGINT, signal.SIGTERM]
NONBLOCKING = frozenset([errno.EAGAIN, errno.EWOULDBLOCK])
# Maximum number of worker threads serving the client requests
MAX_WORKER_THREADS = 10
def __init__(self):
# Read config
read_config()
# Configure logging
try:
loglvl = get_numeric_loglevel(
config.get(os.environ['RAMONA_SECTION'], 'loglevel'))
except:
loglvl = logging.INFO
logging.basicConfig(
level=loglvl,
stream=sys.stderr,
format="%(asctime)s %(levelname)s: %(message)s",
)
try:
self.listenaddr = config.get(os.environ['RAMONA_SECTION'],
'listen')
except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
self.listenaddr = config_defaults['ramona:httpfend']['listenaddr']
self.username = None
self.password = None
try:
self.username = config.get(os.environ['RAMONA_SECTION'],
'username')
self.password = config.get(os.environ['RAMONA_SECTION'],
'password')
except:
pass
if self.username is not None and self.password is None:
L.fatal(
"Configuration error: 'username' option is set, but 'password' option is not set. Please set 'password'"
)
sys.exit(1)
self.logmsgcnt = itertools.count()
self.logmsgs = dict()
self.workers = collections.deque()
self.dyingws = collections.deque() # Dying workers
self.svrsockets = []
for addr in self.listenaddr.split(','):
socket_factory = socketuri.socket_uri(addr)
try:
socks = socket_factory.create_socket_listen()
except socket.error, e:
L.fatal(
"It looks like that server is already running: {0}".format(
e))
sys.exit(1)
self.svrsockets.extend(socks)
if len(self.svrsockets) == 0:
L.fatal(
"There is no http server listen address configured - considering this as fatal error"
)
sys.exit(1)
self.loop = pyev.default_loop()
self.watchers = [
pyev.Signal(sig, self.loop, self.__terminal_signal_cb)
for sig in self.STOPSIGNALS
]
self.dyingwas = pyev.Async(
self.loop, self.__wdied_cb) # Dying workers async. signaling
self.watchers.append(self.dyingwas)
for sock in self.svrsockets:
sock.setblocking(0)
self.watchers.append(
pyev.Io(sock._sock,
pyev.EV_READ,
self.loop,
self.__on_accept,
data=sock._sock.fileno()))
