class service:
def __init__(self):
self.ioloop = ZMQIOLoop()
self.ioloop.install()
return
def process_message_two(self, msg):
print "get thread two message"
print "processing .....", msg
return
def process_message_three(self, msg):
print "get thread three message"
print "processing......", msg
return
def timeout(self):
print "thread one timeout"
data = {}
data['thread'] = 'one'
self.socket_to_others.send(zmqconfig.one_to_two_subject, zmq.SNDMORE)
self.socket_to_others.send(json.dumps(data))
self.socket_to_others.send(zmqconfig.one_to_three_subject, zmq.SNDMORE)
self.socket_to_others.send(json.dumps(data))
self.ioloop.add_timeout(time.time() + 3, self.timeout)
return
def run(self):
self.socket_to_others = zmqconfig.context.socket(zmq.PUB)
self.socket_to_others.bind(zmqconfig.one_zmq_addr)
self.socket_from_two = zmqconfig.context.socket(zmq.SUB)
self.socket_from_two.connect(zmqconfig.two_zmq_addr)
self.socket_from_two.setsockopt(zmq.SUBSCRIBE,
zmqconfig.two_to_one_subject)
self.stream_from_two_sub = zmqstream.ZMQStream(self.socket_from_two)
self.stream_from_two_sub.on_recv(self.process_message_two)
self.socket_from_three = zmqconfig.context.socket(zmq.SUB)
self.socket_from_three.connect(zmqconfig.three_zmq_addr)
self.socket_from_three.setsockopt(zmq.SUBSCRIBE,
zmqconfig.three_to_one_subject)
self.socket_from_three_sub = zmqstream.ZMQStream(
self.socket_from_three)
self.socket_from_three_sub.on_recv(self.process_message_three)
self.ioloop.add_timeout(time.time(), self.timeout)
application = tornado.web.Application(urls)
application.listen(8887)
self.ioloop.start()
return
def start(self, delay_s=0):
self.reset_socks()
loop = ZMQIOLoop()
stream = ZMQStream(self.socks['rep'], io_loop=loop)
def respond(msg):
print 'got %s' % msg
request = msg[0]
if request == 'start':
stream.send('started')
self._start_time = datetime.now()
elif request == 'notify_completion':
time.sleep(delay_s)
stream.send('completed')
stream.on_recv(respond)
loop.start()
class service:
def __init__(self):
self.ioloop = ZMQIOLoop()
self.ioloop.install()
return
def process_message_two(self, msg):
print "get thread two message"
print "processing .....", msg
return
def process_message_three(self, msg):
print "get thread three message"
print "processing......", msg
return
def timeout(self):
print "thread one timeout"
data = {}
data['thread'] = 'one'
self.socket_to_others.send(zmqconfig.one_to_two_subject, zmq.SNDMORE)
self.socket_to_others.send(json.dumps(data))
self.socket_to_others.send(zmqconfig.one_to_three_subject, zmq.SNDMORE)
self.socket_to_others.send(json.dumps(data))
self.ioloop.add_timeout(time.time() + 3, self.timeout)
return
def run(self):
self.socket_to_others = zmqconfig.context.socket(zmq.PUB)
self.socket_to_others.bind(zmqconfig.one_zmq_addr)
self.socket_from_two = zmqconfig.context.socket(zmq.SUB)
self.socket_from_two.connect(zmqconfig.two_zmq_addr)
self.socket_from_two.setsockopt(zmq.SUBSCRIBE, zmqconfig.two_to_one_subject)
self.stream_from_two_sub = zmqstream.ZMQStream(self.socket_from_two)
self.stream_from_two_sub.on_recv(self.process_message_two)
self.socket_from_three = zmqconfig.context.socket(zmq.SUB)
self.socket_from_three.connect(zmqconfig.three_zmq_addr)
self.socket_from_three.setsockopt(zmq.SUBSCRIBE, zmqconfig.three_to_one_subject)
self.socket_from_three_sub = zmqstream.ZMQStream(self.socket_from_three)
self.socket_from_three_sub.on_recv(self.process_message_three)
self.ioloop.add_timeout(time.time(), self.timeout)
application = tornado.web.Application(urls)
application.listen(8887)
self.ioloop.start()
return
loop = ZMQIOLoop()
loop.install()
settings = {
'xsrf_cookies': False,
'debug': True,
'autoreload': True,
'websocket_ping_interval': 60 # 定时发送ping, 保持心跳
}
app = tornado.web.Application([
(r'/ws', PushWebSocket),
], **settings)
if __name__ == '__main__':
port = '8000'
remote = '127.0.0.1:5560' # MPC 消息发布中心 发布 地址
opts, argvs = getopt.getopt(sys.argv[1:], 'r:p:')
for op, value in opts:
if op == '-r':
remote = value
if op == '-p':
port = int(value)
Hub(*remote.split(':'))
app.listen(port)
loop.start()
class ConsoleServer(threading.Thread):
def __init__(self, zmq_port, http_port, killable=False):
super(ConsoleServer,self).__init__()
self.name = "ConsoleServer Thread"
self.daemon = True
self.http_port = http_port
self.zmq_port = zmq_port
self.killable = killable
def run(self):
try:
logger.debug("in thread")
# data storage
self.clients = set()
self.plots = OrderedDict()
# tornado and zmq play nice?
self.ioloop = ZMQIOLoop()
# zmq
self.context = zmq.Context()
self.socket_in = self.context.socket(zmq.SUB)
self.socket_in.connect("tcp://0.0.0.0:"+str(self.zmq_port))
self.socket_in.setsockopt_string(zmq.SUBSCRIBE, "")
# input handler
self.stream = zmqstream.ZMQStream(self.socket_in, io_loop=self.ioloop)
self.stream.on_recv(self.on_recv)
# tornado
self.application = Application(io_loop=self.ioloop)
self.application._server = self
self.server = HTTPServer(self.application)
self.server.listen(self.http_port)
logger.debug("starting IOLoop")
self.ioloop.start()
logger.debug("done thread")
except Exception as e: # capture exceptions from daemonic thread to log file
import traceback as tb
logger.error("Exception in server thread:\n" + str(e) + str(tb.format_exc()))
# receiver code
def on_recv(self, msg):
for s in msg:
# logger.debug("msg: %s" % s)
json_data = json.loads(s.decode())
label = json_data.get('label', '')
cmd = json_data.get('cmd', '')
if cmd == 'create_plot':
self.plots[label] = {}
elif cmd == 'remove_plot':
self.plots.pop(label)
elif cmd == 'clear_plots':
self.plots.clear()
elif cmd == 'set_title':
self.plots[label]['title'] = json_data['title']
elif cmd == 'set_vega':
self.plots[label]['spec'] = json_data['spec']
elif cmd == 'set_svg':
self.plots[label]['svg'] = json_data['svg']
self.plots[label]['css'] = json_data['css']
# broadcast to clients
for c in self.clients:
c.write_message(s)
if self.killable and cmd == 'die':
self.server.stop()
self.ioloop.stop()
class service:
def __init__(self):
self.ioloop = ZMQIOLoop()
self.ioloop.install()
self.clients = {}
self.in_client = "server"
return
def process_message_client(self, msg):
body = json.loads(bytes.decode(msg[1]))
# from client heart
if body["type"] == "heart":
clients = json.loads(bytes.decode(msg[0]))
ip = clients["ip"]
if ip not in self.clients:
self.clients[ip] = {}
self.clients[ip]["time"] = time.time()
self.clients[ip]["tag"] = bytes.decode(msg[0])
else:
self.clients[ip]["time"] = time.time()
pass
# from input t
elif body["type"] == "cmd":
# a = os.system(body["cmd"])
ip_cmd = body["ip_cmd"]
if self.in_client == "server": # input to server
temp_ip_cmd = body["ip_cmd"].split(" ", 1)
if temp_ip_cmd[0] == "ls":
message = {}
message["type"] = "server_message"
if self.clients != {}:
# del overdate
for ip in self.clients:
if time.time() - self.clients[ip]["time"] > float(
server_config.delay):
self.clients[ip]["time"] = 0
message["clients"] = self.clients
else:
message["clients"] = {}
self.socket_to_others.send_string(
server_config.server_to_input_subject, zmq.SNDMORE)
self.socket_to_others.send_string(json.dumps(message))
elif temp_ip_cmd[0] == "ssh":
if temp_ip_cmd[1] in self.clients:
self.in_client = self.clients[temp_ip_cmd[1]]['tag']
message = {}
message["type"] = "state"
message["state"] = temp_ip_cmd[1]
self.socket_to_others.send_string(
server_config.server_to_input_subject, zmq.SNDMORE)
self.socket_to_others.send_string(json.dumps(message))
else:
message = {}
message["type"] = "error"
message["error"] = "no client is %s" % temp_ip_cmd[1]
self.socket_to_others.send_string(
server_config.server_to_input_subject, zmq.SNDMORE)
self.socket_to_others.send_string(json.dumps(message))
else:
message = {}
message["type"] = "error"
message["error"] = "sorry, server no this cmd"
self.socket_to_others.send_string(
server_config.server_to_input_subject, zmq.SNDMORE)
self.socket_to_others.send_string(json.dumps(message))
return
else: # input to client
temp_ip_cmd = body["ip_cmd"].split(" ", 1)
if temp_ip_cmd[0] == "exit":
self.in_client = "server"
message = {}
message["type"] = "state"
message["state"] = "server"
self.socket_to_others.send_string(
server_config.server_to_input_subject, zmq.SNDMORE)
self.socket_to_others.send_string(json.dumps(message))
else:
try:
tag = self.in_client
self.socket_to_others.send_string(tag, zmq.SNDMORE)
self.socket_to_others.send_string(
json.dumps({
"type": "cmd",
"cmd": ip_cmd
}))
except Exception as err:
message = {}
message["type"] = "error"
message["error"] = "unexcept error is occur!"
self.socket_to_others.send_string(
server_config.server_to_input_subject, zmq.SNDMORE)
self.socket_to_others.send_string(json.dumps(message))
# from client cmd_result
elif body["type"] == "cmd_result":
self.socket_to_others.send_string(
server_config.server_to_input_subject, zmq.SNDMORE)
self.socket_to_others.send_string(json.dumps(body))
return
def timeout(self):
# self.socket_to_others.send_string(zmqconfig.server_to_client_subject, zmq.SNDMORE)
# self.socket_to_others.send_string(json.dumps(""))
self.ioloop.add_timeout(time.time() + 3, self.timeout)
return
def run(self):
self.socket_to_others = server_config.context.socket(zmq.PUB)
self.socket_to_others.bind(server_config.server_zmq_addr)
# 服务端收信息,不同机子
self.socket_from_others = server_config.context.socket(zmq.SUB)
self.socket_from_others.setsockopt_string(zmq.SUBSCRIBE, "")
self.socket_from_others.bind(server_config.server_zmq_addr_accept)
self.stream_from_others_sub = zmqstream.ZMQStream(
self.socket_from_others)
self.stream_from_others_sub.on_recv(self.process_message_client)
self.ioloop.add_timeout(time.time(), self.timeout)
# application = tornado.web.Application(urls)
# application.listen(8887)
self.ioloop.start()
return
