def test_client_server_full_flow(self):
storage = MemoryStorage()
self.server = msgpackrpc.Server(SifrServer(storage),
unpack_encoding='utf-8')
port = get_free_port()
self.server.listen(msgpackrpc.Address('127.0.0.1', port))
self.server_thread = threading.Thread(target=self.run_server)
self.server_thread.start()
time.sleep(0.1)
cli = RPCClient('127.0.0.1', port)
cli.incr("foo", 1)
self.assertEqual(1,
storage.count(Hour(datetime.datetime.now(), ["foo"])))
cli.incr("bar", 1, ["minute"])
self.assertEqual(0,
storage.count(Hour(datetime.datetime.now(), ["bar"])))
self.assertEqual(
1, storage.count(Minute(datetime.datetime.now(), ["bar"])))
self.assertEqual(1, cli.count("foo", datetime.datetime.now(), "hour"))
cli.incr_unique("foo", "test")
self.assertEqual(
1, storage.cardinality(Hour(datetime.datetime.now(), ["foo"])))
self.assertEqual(
1, cli.cardinality("foo", datetime.datetime.now(), "hour"))
cli.track("foo", "test")
self.assertEqual(
set(["test"]),
storage.uniques(Hour(datetime.datetime.now(), ["foo"])))
self.assertEqual(set(["test"]),
cli.uniques("foo", datetime.datetime.now(), "hour"))
def run():
try:
self._server = msgpackrpc.Server(self)
self._server.listen(msgpackrpc.Address(*bind_address))
self._server.start()
except Exception as e:
self.exception(str(e))
def run_sum_server():
class SumServer(object):
def sum(self, x, y):
return x + y
server = msgpackrpc.Server(SumServer())
server.listen(msgpackrpc.Address("localhost", 6000))
server.start()
def main():
print("Initialise Server...", flush=True)
server = msgpackrpc.Server(Calculator())
print("Start Server...", flush=True)
port = 18800
host = "localhost"
server.listen(msgpackrpc.Address("localhost", 18800))
print(f"Server is running on: {host}:{port}", flush=True)
server.start()
def setup_env(self):
def _start_server(server):
server.start()
server.close()
self._server = msgpackrpc.Server(TestMessagePackRPC.TestServer())
self._server.listen(self._address)
self._thread = threading.Thread(target=_start_server, args=(self._server,))
self._thread.start()
self._client = msgpackrpc.Client(self._address, unpack_encoding='utf-8')
return self._client;
def main():
parser = argparse.ArgumentParser()
arg = parser.add_argument
arg('path', nargs='?')
arg('--center', action='store_true')
arg('--pca', action='store_true')
args = parser.parse_args()
server = msgpackrpc.Server(
Word2VecServer(path=args.path, center=args.center,
pca_center=args.pca))
server.listen(msgpackrpc.Address('localhost', WORD2VEC_PORT))
print('running...')
server.start()
def serve(daemon=False):
"""Serve echo server in background on localhost.
This returns (server, port). port is number in integer.
To stop, use ``server.shutdown()``
"""
for port in xrange(9000, 10000):
try:
addr = msgpackrpc.Address('localhost', port)
server = msgpackrpc.Server(EchoHandler())
print server
server.listen(addr)
thread = serve_background(server, daemon)
return (addr, server, thread)
except Exception as err:
print err
pass
def doRpcServer(port, stopTimeSec):
class EchoHandler(object):
def Echo123(self, msg1, msg2, msg3):
return ("1:%s 2:%s 3:%s" % (msg1, msg2, msg3))
def EchoStruct(self, msg):
return ("%s" % msg)
addr = msgpackrpc.Address(mylocaladdr, port)
server = msgpackrpc.Server(EchoHandler())
server.listen(addr)
# run thread to stop it after stopTimeSec seconds if > 0
if stopTimeSec > 0:
def myStopRpcServer():
server.stop()
t = threading.Timer(stopTimeSec, myStopRpcServer)
t.start()
server.start()
def msgpack_server(sifrd, config):
storage_type = config.get("storage")
if storage_type == "riak":
import riak
riak_nodes = config.get("riak_nodes")
riak_instance = riak.RiakClient(nodes=riak_nodes)
storage = RiakStorage(riak_instance)
elif storage_type == "redis":
import redis
redis_instance = redis.from_url(config.get("redis_url"))
storage = RedisStorage(redis_instance)
else:
storage = MemoryStorage()
server = msgpackrpc.Server(SifrServer(storage), unpack_encoding='utf-8')
server.listen(
msgpackrpc.Address(config.get("host", "127.0.0.1"),
int(config.get("port", 6000))))
server.start()
def start(self):
try:
server = msgpackrpc.Server(self.handler)
def stop(num, stackframe):
self.logger.critical("Server: get signal %s and stop", num)
server.close()
server.stop()
exit(0)
signal.signal(signal.SIGTERM, stop)
signal.signal(signal.SIGINT, stop)
self.logger.info('Server: listen: %s:%s', self.host, self.port)
server.listen(msgpackrpc.Address(self.host, self.port, socket.AF_INET))
server.start()
except Exception as e:
self.logger.error('Server: get exception: %s\n'
'traceback: %s', e.message, traceback.format_exc())
def main():
signal.signal(signal.SIGINT, signal.SIG_DFL)
rc = libpy.config.readConfig('config.ini')
config = {
'SELF': {
'host': rc.get_skv('SELF', 'host'),
'port': rc.get_skv('SELF', 'port')
},
'RDB': {
'host': rc.get_skv('RDB', 'host'),
'port': rc.get_skv('RDB', 'port'),
'user': rc.get_skv('RDB', 'user'),
'password': rc.get_skv('RDB', 'password'),
'dbname': rc.get_skv('RDB', 'dbname')
}
}
sc = gobject.selfconfig.SelfConfig(**config)
tuser = table.user.User()
server = msgpackrpc.Server(tuser)
server.listen(msgpackrpc.Address(sc.SELF['host'], sc.SELF['port']))
server.start()
def setup_env(self):
def _on_started():
self._server._loop.dettach_periodic_callback()
lock.release()
def _start_server(server):
server._loop.attach_periodic_callback(_on_started, 1)
server.start()
server.close()
self._server = msgpackrpc.Server(TestMessagePackRPC.TestServer())
self._server.listen(self._address)
self._thread = threading.Thread(target=_start_server,
args=(self._server, ))
lock = threading.Lock()
self._thread.start()
lock.acquire()
lock.acquire() # wait for the server to start
self._client = msgpackrpc.Client(self._address,
unpack_encoding='utf-8')
return self._client
# Keras
N_FEATURES = 50000
MAXLEN = 140
DATA_DIR = '/work/rpc'
modelpath = os.path.join(DATA_DIR, 'sentiment_model.yaml')
with open(modelpath) as fd:
model = model_from_yaml(fd.read())
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
model.load_weights(os.path.join(DATA_DIR, 'sentiment_weights.hdf5'))
class SentimentAnalysis(object):
def preprocessing(self, line):
line = line.strip()
X = [util.sentence2array(line, N_FEATURES)]
return sequence.pad_sequences(X, maxlen=MAXLEN)
def predict(self, x):
x = self.preprocessing(x)
return model.predict(x)[0][0]
if __name__ == "__main__":
server = msgpackrpc.Server(SentimentAnalysis())
server.listen(msgpackrpc.Address('0.0.0.0', 18798))
server.start()
is_car_found = threading.Event()
is_follow = threading.Event()
is_stop = threading.Event()
class rpcServer(object):
def push(self, result, timestamp):
print("recv result={}; sender_time={}".format(result, timestamp))
if 'car' in result:
is_car_found.set()
is_follow.set()
def stop(self, result, timestamp):
print('stop simulation')
is_stop.set()
server = msgpackrpc.Server(rpcServer())
def actuator(server):
server.listen(msgpackrpc.Address("172.17.15.21", 18800))
server.start()
server.close()
def control_drone1_move(is_stop):
while 1:
controller_thread = move_drone('Drone1', 45, 0, 0, 90, 5, async=True)
time.sleep(10)
controller_thread = move_drone('Drone1', -45, 0, 0, 90, 5, async=True)
time.sleep(10)
def control_drone1_pic(is_stop):
import bpy
from mathutils import *
import math
import random
import msgpackrpc
import sys
class RenderServer(object):
def renderImage(self, path, luku):
random.seed()
rotations = [(0, math.pi * 1.5, 0), (math.pi * 1, 0, 0),
(math.pi * 0.5, 0, 0), (math.pi * 1.5, 0, 0), (0, 0, 0),
(0, math.pi * 0.5, 0)]
noppa = bpy.data.objects["Noppa"]
noppa.rotation_mode = 'XYZ'
noppa.rotation_euler = (rotations[luku])
noppa.rotation_euler[2] = random.random() * 2 * math.pi
noppa.location = (random.random() - 0.5, random.random() * 2 - 1, 0.50)
bpy.data.scenes['Scene'].render.filepath = path
bpy.data.scenes['Scene'].render.image_settings.file_format = 'JPEG'
bpy.ops.render.render(write_still=True)
def exit(self):
sys.exit()
server = msgpackrpc.Server(RenderServer())
server.listen(msgpackrpc.Address("localhost", 18800))
server.start()
cb = None
if (self.tensorboard_callback != None):
cb = [self.tensorboard_callback]
train_epochs = 5
self.model.fit(self.train_ds,
validation_data=self.val_ds,
shuffle=True,
epochs=self.epoch + train_epochs,
callbacks=cb,
initial_epoch=self.epoch,
use_multiprocessing=True)
self.epoch = self.epoch + train_epochs
def evaluate(self):
results = self.model.evaluate(self.val_ds)
print("test loss, test acc:", results)
def exit(self):
sys.exit()
if __name__ == '__main__':
print("start")
server = msgpackrpc.Server(TrainServer())
server.listen(msgpackrpc.Address("localhost", 18801))
server.start()
def run_server(ip, port):
print('start DataForwarder at {}:{}'.format(ip, port))
server = msgpackrpc.Server(DisplayServer())
server.listen(msgpackrpc.Address(ip, port))
server.start()
def run(self):
self.server = msgpackrpc.Server(TestService())
self.server.listen(msgpackrpc.Address("localhost", PORT))
self.server.start()
#logging
logging.basicConfig(level=logging.DEBUG)
# config
logging.info('Loading configuration')
settings = get_appsettings(argv[1], 'triage')
# mongo
logging.info('Connecting to mongo at: mongodb://' + settings['mongodb.host'] +
'/' + settings['mongodb.db_name'])
mongoengine.connect(settings['mongodb.db_name'], host=settings['mongodb.host'])
class LoggingServer:
def error(self, msg):
try:
error = Error.create_from_msg(msg)
error.save()
except Exception:
logging.exception('Failed to process error')
logging.info('Creating server at ' + settings['errorserver.host'] + ':' +
settings['errorserver.port'])
server = msgpackrpc.Server(LoggingServer())
server.listen(
msgpackrpc.Address(settings['errorserver.host'],
settings['errorserver.port']))
logging.info('Serving!')
server.start()
print(
"lxc-attach -n %s -- /bin/bash -c 'cd /var/www/shareddata%s && %s > /var/www/shareddata/%s/out.txt && echo 0 > /var/www/shareddata/%s/status.txt' "
% (image_id, path_to_file, cmd_line, jobname, jobname))
os.system(
"lxc-attach -n %s -- /bin/bash -c 'cd /var/www/shareddata%s && %s > /var/www/shareddata/%s/out.txt && echo 0 > /var/www/shareddata/%s/status.txt' "
% (image_id, path_to_file, cmd_line, jobname, jobname))
time.sleep(time_out)
with open("/var/www/shareddata/%s/status.txt" % jobname,
"r") as fp:
status_now = fp.read()
if status_now == 0:
break
return 0
def delete(self, job_name):
with open("/var/www/shareddata/%s/config.txt" % job_name, "r") as fp:
image_id = fp.read()
print(image_id)
os.system("lxc-stop -n %s" % image_id)
print(job_name)
os.system("rm -rf /var/www/shareddata/%s" % job_name)
# am i right...? rm -rf
return 0
server = msgpackrpc.Server(deamon_server())
server.listen(msgpackrpc.Address("localhost", 8080))
server.start()
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
category_index,
instance_masks=output_dict.get('detection_masks'),
use_normalized_coordinates=True,
line_thickness=8)
im = Image.fromarray(image_np)
im.save('abc.jpg')
print("Done")
return "Done"
#except Exception as inst:
server = msgpackrpc.Server(InferenceServer())
server.listen(msgpackrpc.Address("localhost", 18800))
server.start()
# for image_path in TEST_IMAGE_PATHS:
# image = Image.open(image_path)
# # the array based representation of the image will be used later in order to prepare the
# # result image with boxes and labels on it.
# image_np = load_image_into_numpy_array(image)
# # Expand dimensions since the model expects images to have shape: [1, None, None, 3]
# image_np_expanded = np.expand_dims(image_np, axis=0)
# # Actual detection.
# output_dict = run_inference_for_single_image(image_np, detection_graph)
# # Visualization of the results of a detection.
# vis_util.visualize_boxes_and_labels_on_image_array(
# image_np,
\ \/ \/ / _ \ | _/ _ \| | | | '_ \ / _` | / _` | | | / /\ \ | _ /
\ /\ / __/ | || (_) | |_| | | | | (_| | | (_| | | |____ / ____ \| | \ \
\/ \/ \___| |_| \___/ \__,_|_| |_|\__,_| \__,_| \_____/_/ \_\_| \_\
___..............._
__.. ' _'.""" """\\""" """""- .`-._
______.-' (_) | \\ ` \\`-. _
/_ --------------'-------\\---....______\\__`.` -..___
| T _.----._ Xxx|x... | _.._`--. _
| | .' ..--.. `. XXX|XXXXXXXXXxx== | .'.---..`. -._
\_j / / __ \ \ XXX|XXXXXXXXXXX== | / / __ \ \ `-.
_| | | / \ | | XXX|""' | / | / \ | | |
|__\_j | \__/ | L__________|_______________|_____j | \__/ | L__________J
`'\ \ / ./__________________________________\ \ / /___________\
`.`----'.' dp `.`----'.'
`""" "' `" """'
"""
class FileServer(object):
def push(self, result, timestamp):
if 'car' in result:
print(display_text)
return 'received {} bytes'.format(len(result))
# print(display_text)
server = msgpackrpc.Server(FileServer())
server.listen(msgpackrpc.Address('172.17.51.5', 18900))
print('start display service on 172.17.51.5:18900')
server.start()
g = np.frombuffer(data[b'g'], dtype=np.uint8)
b = np.frombuffer(data[b'b'], dtype=np.uint8)
r.resize((h, w))
g.resize((h, w))
b.resize((h, w))
img[:, :, 0] = b
img[:, :, 1] = g
img[:, :, 2] = r
result = {"model": "yolo", "objects": []}
result["objects"].append({
"class": "mouse",
"xmin": 200,
"ymin": 200,
"width": 100,
"height": 100
})
result["objects"].append({
"class": "mouse",
"xmin": 150,
"ymin": 150,
"width": 50,
"height": 50
})
print(result)
return json.dumps(result)
server = msgpackrpc.Server(ImageProcess())
server.listen(msgpackrpc.Address("127.0.0.1", 8800))
server.start()
# https://github.com/msgpack-rpc/msgpack-rpc-python#server
import msgpackrpc
class SumServer(object):
def sum(self, x, y):
return x + y
server = msgpackrpc.Server(SumServer())
server.listen(msgpackrpc.Address("localhost", 18800))
server.start()
def run_server(ip, port, forward_to_ip, forward_to_port):
print('start ColorFinder at {}:{}'.format(ip, port))
server = msgpackrpc.Server(ColorFinder(forward_to_ip, forward_to_port))
server.listen(msgpackrpc.Address(ip, port))
server.start()
def __init__(self):
self._server = msgpackrpc.Server(self)
self._blocking_thread = None
self._id = str(uuid.uuid1())
def main():
server = msgpackrpc.Server(PropertyServer())
server.listen(msgpackrpc.Address("localhost", 18800))
print("start serving...")
server.start()
import msgpackrpc
class EchoHandler(object):
def Echo123(self, msg):
(msg1, msg2, msg3) = msg
return ("1:%s 2:%s 3:%s" % (msg1, msg2, msg3))
def EchoStruct(self, msg):
return ("msg:%s" % msg)
if __name__ == '__main__':
addr = msgpackrpc.Address('localhost', 9000)
server = msgpackrpc.Server(EchoHandler())
server.listen(addr)
server.start()
import msgpackrpc
class Something(object):
def ListTest(self, name, position):
for i in range(len(name)):
print type(name[i]), name[i], type(position[i]), position[i]
server = msgpackrpc.Server(Something())
server.listen(msgpackrpc.Address("", 18800))
server.start()
def __init__ (self):
super().__init__()
self.adaptors = {}
def register_adaptor (self, adaptor):
self.adaptors[adaptor.tickerid] = adaptor
def ohlcv (self, tickerid, resolution, count):
return self.adaptors[tickerid].ohlcv(resolution, count)
def step_ohlcv (self, tickerid, resolution, next_clock):
return self.adaptors[tickerid].step_ohlcv(resolution, next_clock)
if __name__ == '__main__':
import os
from gevent.server import StreamServer
from pine.market.bitmex import BitMexOhlcAdaptor
from pine.market.bitflyer import BitFlyerOhlcAdaptor
from pine.market.base import PROXY_PORT
server = OhlcvProxyServer()
server.register_adaptor(BitMexOhlcAdaptor())
server.register_adaptor(BitFlyerOhlcAdaptor())
port = int(os.environ.get('PORT', PROXY_PORT))
#server = StreamServer(('127.0.0.1', port), server)
#server.serve_forever()
server = msgpackrpc.Server(server, unpack_encoding='utf-8')
server.listen(msgpackrpc.Address('127.0.0.1', port))
server.start()
