def start_srv(self):
self.fwdcounter[current_process().name] = 0
self.fwdqueue[current_process().name] = Queue()
self.statqueue[current_process().name] = Queue()
self.errqueue[current_process().name] = Queue()
self.statlog[current_process().name] = StatLog('state_%s' %
current_process().name)
self.errlog[current_process().name] = StatLog('err_%s' %
current_process().name)
self.fwdlog[current_process().name] = StatLog('fwd_%s' %
current_process().name)
errworker = threading.Thread(
target=logger_worker,
args=(self.errqueue[current_process().name],
self.errlog[current_process().name]))
errworker.start()
statworker = threading.Thread(
target=logger_worker,
args=(self.statqueue[current_process().name],
self.statlog[current_process().name]))
statworker.start()
fwdworker = threading.Thread(
target=logger_worker,
args=(self.fwdqueue[current_process().name],
self.fwdlog[current_process().name]))
fwdworker.start()
#recvworker= threading.Thread(target=logger_worker,args=(recvqueue,recvlog))
#recvworker.start()
threading.Thread(target=self.report_status).start()
server.StreamServer(self.listener,
self.handle_new_accept).serve_forever()
def main():
os = octp_server.OctpServer({}, 'test', server_info)
s = server.StreamServer(tuple(server_info['addr'].values()), handle)
s.start()
os.start()
s.serve_forever()
os.stop()
def run(self):
"""
Starting Server
"""
self.musserver = server.StreamServer((self.serverip, self.serverport),
self.handle)
self.musserver.start()
ConsoleLogger.log(
"INF", "Mus server running on " + self.serverip + ':' +
str(self.serverport))
def start(self):
"""
Start info server method
"""
localserver = server.StreamServer((self.localip, self.serverport), self.handle)
gsignal(signal.SIGTERM, localserver.stop)
gsignal(signal.SIGINT, localserver.stop)
localserver.start()
ConsoleLogger.log("INF", "Info server running on " + self.localip + ':' + str(self.serverport))
if self.localip != '127.0.0.1':
lbserver = server.StreamServer(('127.0.0.1', self.serverport), self.handle)
gsignal(signal.SIGTERM, lbserver.stop)
gsignal(signal.SIGINT, lbserver.stop)
lbserver.start()
ConsoleLogger.log("INF", "Info server running on 127.0.0.1:" + str(self.serverport))
if len(self.remoteip) > 0:
remoteserver = server.StreamServer(('127.0.0.1', self.serverport), self.handle)
gsignal(signal.SIGTERM, remoteserver.stop)
gsignal(signal.SIGINT, remoteserver.stop)
remoteserver.start()
ConsoleLogger.log("INF", "Info server running on " + self.remoteip + ':' + str(self.serverport))
def main(*cfgs):
if not cfgs:
print 'no configure'
return
ps = serve.ProxyServer(cfgs)
initlog(getattr(logging, ps.config.get('loglevel', 'WARNING')))
logger.info('ProxyServer inited')
addr = (ps.config.get('localip', ''), ps.config.get('localport', 8118))
try:
try:
server.StreamServer(addr, ps.http_handler).serve_forever()
except KeyboardInterrupt:
pass
finally:
ps.final()
def main(*cfgs):
if not cfgs:
print 'no configure'
return
config = import_config(*cfgs)
initlog(getattr(logging, config.get('loglevel', 'WARNING')),
config.get('logfile', None))
addr = (config.get('localip', ''), config.get('localport', 8118))
ps = serve.ProxyServer(config)
try:
if config.get('dnsproxy'):
gevent.spawn(ps.dns.server, config.get('dnsport', 53))
try:
server.StreamServer(addr, ps.handler).serve_forever()
except KeyboardInterrupt:
pass
finally:
ps.final()
def main(port=11111):
s = server.StreamServer(('0.0.0.0', port), handler)
s.start()
s.serve_forever()
if error_code:
fileobj.write(int2hex(error_code, int_len=2))
fileobj.close()
return
result = ''
result += int2hex(4 + 2 + len(result_tlv))
result += int2hex(RESULT_UPLOAD_SUCCESS, int_len=2)
result += result_tlv
fileobj.write(result)
fileobj.flush()
fileobj.close()
s = server.StreamServer((settings.SERVER_IP, settings.SERVER_PORT),
do_upload,
backlog=settings.SERVER_BACKLOG)
# s.init_socket() # gevent 1.x
s.pre_start() # gevent 0.13
_smng = SocketManager()
_smng.setDaemon(True)
_smng.start()
def serve_forever(server_):
note('starting server')
_m = SocketManager()
_m.setDaemon(True)
_m.start()
try:
def setUp(self):
self.server = server.StreamServer(('127.0.0.1', 0), readall)
self.server.start()
default=':6601',
type=parse_address,
help='address:port for the reference backend.')
parser.add_argument('--actual',
default=':6602',
type=parse_address,
help='address:port for the actual backend.')
return parser.parse_args()
def parse_address(address):
"""Convert host:port or port to address to pass to connect."""
if ':' not in address:
return ('', int(address))
host, port = address.rsplit(':', 1)
return (host, int(port))
if __name__ == '__main__':
args = parse_args()
def handle(client, address):
"""Wrapper that adds reference and actual backends to proxy calls."""
return proxy(client, address, args.reference, args.actual)
try:
server.StreamServer(args.listen, handle).serve_forever()
except (KeyboardInterrupt, SystemExit):
pass
def setUp(self):
self.server = server.StreamServer(greentest.DEFAULT_BIND_ADDR_TUPLE,
readall)
self.server.start()
def run(self):
s = server.StreamServer(("localhost", 9991), self.pg_proxy)
s.serve_forever()
def start(self):
"""
其实这里就是启动StreamServer
"""
self._server = server.StreamServer((self._ip, self._port), handle=self._handle)
self._server.start()
for c in self.children:
print 'sending to', c
gevent.spawn(c[0].send, message)
def listen(self, socket, address):
f = socket.makefile()
while True:
line = f.readline()
if not line:
print 'client died'
break
self.write_to_children(address, line)
master_listen = (hostname, 4002)
master = server.StreamServer(master_listen, master())
Chat = ChatHandler(master_listen)
s = server.StreamServer((hostname, 4001), Chat)
s.pre_start()
def serve_forever(server, master_listen):
Chat = ChatHandler(master_listen)
server.set_handle(Chat)
try:
gevent.spawn_later(1, server.start_accepting)
try:
server._stopped_event.wait()
except:
for c in self.children:
print 'sending to', c
gevent.spawn(c[0].send, message)
def listen(self, socket, address):
f = socket.makefile()
while True:
line = f.readline()
if not line:
print 'client died'
break
self.write_to_children(address, line)
master_listen = ('127.0.0.1', 4002)
master = server.StreamServer(master_listen, master())
Chat = ChatHandler(master_listen)
s = server.StreamServer(('127.0.0.1', 4001), Chat)
s.pre_start()
def serve_forever(server, master_listen):
Chat = ChatHandler(master_listen)
server.set_handle(Chat)
try:
gevent.spawn_later(1, server.start_accepting)
try:
server._stopped_event.wait()
except:
