Backups/multi-user
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(rcf): code formating

Browse Source
This commit is contained in:
Swann Martinez
2019-04-18 15:05:48 +02:00
parent 2a9931dc0c
commit 91611f01e2
5 changed files with 122 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
client.py
View File

@ -69,21 +69,21 @@ class RCFClient(object):
self.pipe, peer = zpipe(self.ctx) self.pipe, peer = zpipe(self.ctx)
self.queue = queue.Queue() self.queue = queue.Queue()
self.agent = threading.Thread( self.agent = threading.Thread(
target=rcf_client_agent, args=(self.ctx, peer,self.queue),name="net-agent") target=rcf_client_agent, args=(self.ctx, peer, self.queue), name="net-agent")
self.agent.daemon = True self.agent.daemon = True
self.agent.start() self.agent.start()
def connect(self, id, address, port): def connect(self, id, address, port):
self.pipe.send_multipart([b"CONNECT", (id.encode() if isinstance( self.pipe.send_multipart([b"CONNECT", (id.encode() if isinstance(
id, str) else id), (address.encode() if isinstance( id, str) else id), (address.encode() if isinstance(
address, str) else address), b'%d' % port]) address, str) else address), b'%d' % port])
def set(self, key, value=None): def set(self, key, value=None):
"""Set new value in distributed hash table """Set new value in distributed hash table
Sends [SET][key][value] to the agent Sends [SET][key][value] to the agent
""" """
self.pipe.send_multipart( self.pipe.send_multipart(
[b"SET", umsgpack.packb(key),( umsgpack.packb(value) if value else umsgpack.packb('None') )]) [b"SET", umsgpack.packb(key), (umsgpack.packb(value) if value else umsgpack.packb('None'))])
def get(self, key): def get(self, key):
"""Lookup value in distributed hash table """Lookup value in distributed hash table
@ -157,7 +157,7 @@ class RCFClientAgent(object):
self.publisher.setsockopt(zmq.SNDHWM, 60) self.publisher.setsockopt(zmq.SNDHWM, 60)
self.publisher.linger = 0 self.publisher.linger = 0
self.serial, peer = zpipe(self.ctx) self.serial, peer = zpipe(self.ctx)
self.serial_agent = threading.Thread( self.serial_agent = threading.Thread(
target=serialization_agent, args=(self.ctx, peer), name="serial-agent") target=serialization_agent, args=(self.ctx, peer), name="serial-agent")
self.serial_agent.daemon = True self.serial_agent.daemon = True
self.serial_agent.start() self.serial_agent.start()
@ -189,9 +189,8 @@ class RCFClientAgent(object):
value = helpers.dump(key) value = helpers.dump(key)
if value: if value:
logger.info("{} dumped".format(key)) rcfmsg = message.RCFMessage(
# Send key-value pair on to server key=key, id=self.id, mtype="", body=value)
rcfmsg = message.RCFMessage(key=key, id=self.id, mtype="", body=value)
rcfmsg.store(self.property_map) rcfmsg.store(self.property_map)
rcfmsg.send(self.publisher) rcfmsg.send(self.publisher)
@ -203,17 +202,18 @@ class RCFClientAgent(object):
key = umsgpack.unpackb(msg[0]) key = umsgpack.unpackb(msg[0])
for k in self.property_map.keys(): for k in self.property_map.keys():
if key in k: if key in k:
value.append([k,self.property_map.get(k).body]) value.append([k, self.property_map.get(k).body])
# value = [self.property_map.get(key) for key in keys] # value = [self.property_map.get(key) for key in keys]
# value = self.property_map.get(key) # value = self.property_map.get(key)
self.pipe.send(umsgpack.packb(value) if value else umsgpack.packb('')) self.pipe.send(umsgpack.packb(value)
if value else umsgpack.packb(''))
elif command == b"LIST": elif command == b"LIST":
self.pipe.send(umsgpack.packb(list(self.property_map))) self.pipe.send(umsgpack.packb(list(self.property_map)))
def rcf_client_agent(ctx, pipe,queue): def rcf_client_agent(ctx, pipe, queue):
agent = RCFClientAgent(ctx, pipe) agent = RCFClientAgent(ctx, pipe)
server = None server = None
update_queue = queue update_queue = queue
@ -230,7 +230,7 @@ def rcf_client_agent(ctx, pipe,queue):
server = agent.server server = agent.server
if agent.server: if agent.server:
logger.info("%s: waiting for server at %s:%d...", logger.info("%s: waiting for server at %s:%d...",
agent.id.decode(),server.address, server.port) agent.id.decode(), server.address, server.port)
server.snapshot.send(b"SNAPSHOT_REQUEST") server.snapshot.send(b"SNAPSHOT_REQUEST")
agent.state = State.SYNCING agent.state = State.SYNCING
server_socket = server.snapshot server_socket = server.snapshot
@ -262,20 +262,21 @@ def rcf_client_agent(ctx, pipe,queue):
with lock: with lock:
client_dict = helpers.init_client(key=client_key) client_dict = helpers.init_client(key=client_key)
client_store = message.RCFMessage(key=client_key, id=agent.id.decode(),body=client_dict) client_store = message.RCFMessage(
key=client_key, id=agent.id.decode(), body=client_dict)
logger.info(client_store) logger.info(client_store)
client_store.store(agent.property_map) client_store.store(agent.property_map)
logger.info("snapshot complete") logger.info("snapshot complete")
agent.state = State.ACTIVE agent.state = State.ACTIVE
else: else:
helpers.load(rcfmsg.key,rcfmsg.body) helpers.load(rcfmsg.key, rcfmsg.body)
rcfmsg.store(agent.property_map) rcfmsg.store(agent.property_map)
elif agent.state == State.ACTIVE: elif agent.state == State.ACTIVE:
if rcfmsg.id != agent.id: if rcfmsg.id != agent.id:
# update_queue.put((rcfmsg.key,rcfmsg.body)) # update_queue.put((rcfmsg.key,rcfmsg.body))
with lock: with lock:
helpers.load(rcfmsg.key,rcfmsg.body) helpers.load(rcfmsg.key, rcfmsg.body)
# logger.info("load") # logger.info("load")
# agent.serial.send_multipart([b"LOAD", umsgpack.packb(rcfmsg.key), umsgpack.packb(rcfmsg.body)]) # agent.serial.send_multipart([b"LOAD", umsgpack.packb(rcfmsg.key), umsgpack.packb(rcfmsg.body)])
@ -320,8 +321,7 @@ class SerializationAgent(object):
key = umsgpack.unpackb(msg[0]) key = umsgpack.unpackb(msg[0])
value = umsgpack.unpackb(msg[1]) value = umsgpack.unpackb(msg[1])
helpers.load(key, value)
helpers.load(key,value)
self.pipe.send_multipart([b"DONE"]) self.pipe.send_multipart([b"DONE"])
@ -345,7 +345,3 @@ def serialization_agent(ctx, pipe):
if agent.pipe in items: if agent.pipe in items:
agent.control_message() agent.control_message()

17
draw.py
View File

@ -7,6 +7,7 @@ import mathutils
from bpy_extras import view3d_utils from bpy_extras import view3d_utils
from gpu_extras.batch import batch_for_shader from gpu_extras.batch import batch_for_shader
def view3d_find(): def view3d_find():
for area in bpy.data.window_managers[0].windows[0].screen.areas: for area in bpy.data.window_managers[0].windows[0].screen.areas:
if area.type == 'VIEW_3D': if area.type == 'VIEW_3D':
@ -60,12 +61,12 @@ def get_client_2d(coords):
if area and region and rv3d: if area and region and rv3d:
return view3d_utils.location_3d_to_region_2d(region, rv3d, coords) return view3d_utils.location_3d_to_region_2d(region, rv3d, coords)
else: else:
return (0,0) return (0, 0)
class HUD(object): class HUD(object):
def __init__(self, client_instance = None): def __init__(self, client_instance=None):
self.d3d_items = {} self.d3d_items = {}
self.d2d_items = {} self.d2d_items = {}
self.draw3d_handle = None self.draw3d_handle = None
@ -123,7 +124,7 @@ class HUD(object):
bbox_corners = [ob.matrix_world @ mathutils.Vector(corner) for corner in ob.bound_box] bbox_corners = [ob.matrix_world @ mathutils.Vector(corner) for corner in ob.bound_box]
coords = [(point.x, point.y, point.z) coords = [(point.x, point.y, point.z)
for point in bbox_corners] for point in bbox_corners]
shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR') shader = gpu.shader.from_builtin('3D_UNIFORM_COLOR')
@ -132,9 +133,8 @@ class HUD(object):
batch = batch_for_shader( batch = batch_for_shader(
shader, 'LINES', {"pos": coords}, indices=indices) shader, 'LINES', {"pos": coords}, indices=indices)
self.d3d_items["{}/{}".format(client[0],select_ob)]=(shader, batch, color) self.d3d_items["{}/{}".format(client[0],
select_ob)] = (shader, batch, color)
def draw_clients(self): def draw_clients(self):
clients = self.client.get("Client") clients = self.client.get("Client")
@ -156,8 +156,8 @@ class HUD(object):
batch = batch_for_shader( batch = batch_for_shader(
shader, 'LINES', {"pos": position}, indices=indices) shader, 'LINES', {"pos": position}, indices=indices)
self.d3d_items[client[0]]=(shader, batch, color) self.d3d_items[client[0]] = (shader, batch, color)
self.d2d_items[client[0]]=(position[1], name,color) self.d2d_items[client[0]] = (position[1], name, color)
except Exception as e: except Exception as e:
print("Draw client exception {}".format(e)) print("Draw client exception {}".format(e))
@ -191,4 +191,3 @@ class HUD(object):
# Draw clients # Draw clients
self.draw_clients() self.draw_clients()
self.draw_selected_object() self.draw_selected_object()

44
helpers.py
View File

@ -11,6 +11,7 @@ def refresh_window():
import bpy import bpy
bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1) bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)
def get_selected_objects(scene): def get_selected_objects(scene):
selected_objects = [] selected_objects = []
for obj in scene.objects: for obj in scene.objects:
@ -20,37 +21,38 @@ def get_selected_objects(scene):
return selected_objects return selected_objects
# LOAD HELPERS # LOAD HELPERS
def load(key, value): def load(key, value):
target = resolve_bpy_path(key) target = resolve_bpy_path(key)
target_type = key.split('/')[0] target_type = key.split('/')[0]
if target_type == 'Object': if target_type == 'Object':
load_object(target=target, data=value, load_object(target=target, data=value,
create=True) create=True)
elif target_type == 'Mesh': elif target_type == 'Mesh':
load_mesh(target=target, data=value, load_mesh(target=target, data=value,
create=True) create=True)
elif target_type == 'Collection': elif target_type == 'Collection':
load_collection(target=target, data=value, load_collection(target=target, data=value,
create=True) create=True)
elif target_type == 'Material': elif target_type == 'Material':
load_material(target=target, data=value, load_material(target=target, data=value,
create=True) create=True)
elif target_type == 'Grease Pencil': elif target_type == 'Grease Pencil':
load_gpencil(target=target, data=value, load_gpencil(target=target, data=value,
create=True) create=True)
elif target_type == 'Scene': elif target_type == 'Scene':
load_scene(target=target, data=value, load_scene(target=target, data=value,
create=True) create=True)
elif 'Light' in target_type: elif 'Light' in target_type:
load_light(target=target, data=value, load_light(target=target, data=value,
create=True) create=True)
elif target_type == 'Camera': elif target_type == 'Camera':
load_default(target=target, data=value, load_default(target=target, data=value,
create=True, type=target_type) create=True, type=target_type)
elif target_type == 'Client': elif target_type == 'Client':
load_client(key.split('/')[1],value) load_client(key.split('/')[1], value)
def resolve_bpy_path(path): def resolve_bpy_path(path):
@ -69,20 +71,19 @@ def resolve_bpy_path(path):
return item return item
def load_client(client=None,data=None): def load_client(client=None, data=None):
C = bpy.context C = bpy.context
D = bpy.data D = bpy.data
if client and data: if client and data:
# localy_selected = get_selected_objects(C.scene) # localy_selected = get_selected_objects(C.scene)
# Draw client # Draw client
#Load selected object # Load selected object
if data['active_objects']: if data['active_objects']:
for obj in C.scene.objects: for obj in C.scene.objects:
if obj.name in data['active_objects']: if obj.name in data['active_objects']:
D.objects[obj.name].hide_select = True D.objects[obj.name].hide_select = True
else: else:
print(data['active_objects'])
D.objects[obj.name].hide_select = False D.objects[obj.name].hide_select = False
pass pass
@ -182,7 +183,7 @@ def load_scene(target=None, data=None, create=False):
target.collection.objects.link(bpy.data.objects[object]) target.collection.objects.link(bpy.data.objects[object])
for object in target.collection.objects.keys(): for object in target.collection.objects.keys():
if object not in data["collection"]["objects"]: if object not in data["collection"]["objects"]:
target.collection.objects.unlink(bpy.data.objects[object]) target.collection.objects.unlink(bpy.data.objects[object])
# load collections # load collections
# TODO: Recursive link # TODO: Recursive link
@ -242,11 +243,10 @@ def load_material(target=None, data=None, create=False):
print("Material loading error") print("Material loading error")
def load_gpencil_layer(target=None,data=None, create=False): def load_gpencil_layer(target=None, data=None, create=False):
dump_anything.load(target, data) dump_anything.load(target, data)
for frame in data["frames"]: for frame in data["frames"]:
try: try:
tframe = target.frames[frame] tframe = target.frames[frame]
@ -258,7 +258,8 @@ def load_gpencil_layer(target=None,data=None, create=False):
tstroke = tframe.strokes[stroke] tstroke = tframe.strokes[stroke]
except: except:
tstroke = tframe.strokes.new() tstroke = tframe.strokes.new()
dump_anything.load(tstroke, data["frames"][frame]["strokes"][stroke]) dump_anything.load(
tstroke, data["frames"][frame]["strokes"][stroke])
for point in data["frames"][frame]["strokes"][stroke]["points"]: for point in data["frames"][frame]["strokes"][stroke]["points"]:
p = data["frames"][frame]["strokes"][stroke]["points"][point] p = data["frames"][frame]["strokes"][stroke]["points"][point]
@ -281,7 +282,8 @@ def load_gpencil(target=None, data=None, create=False):
gp_layer = target.layers.new(data["layers"][layer]["info"]) gp_layer = target.layers.new(data["layers"][layer]["info"])
else: else:
gp_layer = target.layers[layer] gp_layer = target.layers[layer]
load_gpencil_layer(target=gp_layer,data=data["layers"][layer],create=create) load_gpencil_layer(
target=gp_layer, data=data["layers"][layer], create=create)
# Load other meshes metadata # Load other meshes metadata
dump_anything.load(target, data) dump_anything.load(target, data)
except: except:
@ -310,6 +312,8 @@ def load_default(target=None, data=None, create=False, type=None):
print("default loading error") print("default loading error")
# DUMP HELPERS # DUMP HELPERS
def dump(key): def dump(key):
target = resolve_bpy_path(key) target = resolve_bpy_path(key)
target_type = key.split('/')[0] target_type = key.split('/')[0]
@ -318,7 +322,8 @@ def dump(key):
if target_type == 'Material': if target_type == 'Material':
data = dump_datablock_attibute(target, ['name', 'node_tree'], 7) data = dump_datablock_attibute(target, ['name', 'node_tree'], 7)
elif target_type == 'Grease Pencil': elif target_type == 'Grease Pencil':
data = dump_datablock_attibute(target, ['name', 'layers','materials'], 9) data = dump_datablock_attibute(
target, ['name', 'layers', 'materials'], 9)
elif target_type == 'Camera': elif target_type == 'Camera':
data = dump_datablock(target, 1) data = dump_datablock(target, 1)
elif target_type == 'Light': elif target_type == 'Light':
@ -374,8 +379,9 @@ def init_client(key=None):
C = bpy.context C = bpy.context
Net = C.scene.session_settings Net = C.scene.session_settings
client_dict['location'] = [[0,0,0],[0,0,0],[0,0,0],[0,0,0]] client_dict['location'] = [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
client_dict['color'] = [Net.client_color.r,Net.client_color.g,Net.client_color.b,1] client_dict['color'] = [Net.client_color.r,
Net.client_color.g, Net.client_color.b, 1]
client_dict['active_objects'] = get_selected_objects(C.view_layer) client_dict['active_objects'] = get_selected_objects(C.view_layer)

55
operators.py
View File

@ -31,7 +31,7 @@ update_list = {}
SUPPORTED_DATABLOCKS = ['collections', 'meshes', 'objects', SUPPORTED_DATABLOCKS = ['collections', 'meshes', 'objects',
'materials', 'textures', 'lights', 'cameras', 'actions', 'armatures', 'grease_pencils'] 'materials', 'textures', 'lights', 'cameras', 'actions', 'armatures', 'grease_pencils']
SUPPORTED_TYPES = ['Material', SUPPORTED_TYPES = ['Material',
'Texture', 'Light', 'Camera','Mesh', 'Grease Pencil', 'Object', 'Action', 'Armature','Collection', 'Scene'] 'Texture', 'Light', 'Camera', 'Mesh', 'Grease Pencil', 'Object', 'Action', 'Armature', 'Collection', 'Scene']
# UTILITY FUNCTIONS # UTILITY FUNCTIONS
@ -91,7 +91,7 @@ def update_selected_object(context):
key = "net/objects/{}".format(client_instance.id.decode()) key = "net/objects/{}".format(client_instance.id.decode())
data = {} data = {}
data['color'] = [session.client_instance_color.r, data['color'] = [session.client_instance_color.r,
session.client_instance_color.g, session.client_instance_color.b] session.client_instance_color.g, session.client_instance_color.b]
data['object'] = session.active_object.name data['object'] = session.active_object.name
client_instance.push_update( client_instance.push_update(
key, 'client_instanceObject', data) key, 'client_instanceObject', data)
@ -101,7 +101,7 @@ def update_selected_object(context):
session.active_object = None session.active_object = None
data = {} data = {}
data['color'] = [session.client_instance_color.r, data['color'] = [session.client_instance_color.r,
session.client_instance_color.g, session.client_instance_color.b] session.client_instance_color.g, session.client_instance_color.b]
data['object'] = None data['object'] = None
key = "net/objects/{}".format(client_instance.id.decode()) key = "net/objects/{}".format(client_instance.id.decode())
client_instance.push_update(key, 'client_instanceObject', data) client_instance.push_update(key, 'client_instanceObject', data)
@ -115,8 +115,8 @@ def init_datablocks():
global client_instance global client_instance
for datatype in SUPPORTED_TYPES: for datatype in SUPPORTED_TYPES:
for item in getattr(bpy.data,helpers.CORRESPONDANCE[datatype]): for item in getattr(bpy.data, helpers.CORRESPONDANCE[datatype]):
key = "{}/{}".format(datatype,item.name) key = "{}/{}".format(datatype, item.name)
print(key) print(key)
client_instance.set(key) client_instance.set(key)
@ -160,6 +160,8 @@ def unregister_ticks():
bpy.app.timers.unregister(default_tick) bpy.app.timers.unregister(default_tick)
# OPERATORS # OPERATORS
class session_join(bpy.types.Operator): class session_join(bpy.types.Operator):
bl_idname = "session.join" bl_idname = "session.join"
@ -186,12 +188,12 @@ class session_join(bpy.types.Operator):
username = str(context.scene.session_settings.username) username = str(context.scene.session_settings.username)
if len(net_settings.ip)<1: if len(net_settings.ip) < 1:
net_settings.ip = "127.0.0.1" net_settings.ip = "127.0.0.1"
client_instance = client.RCFClient() client_instance = client.RCFClient()
client_instance.connect(net_settings.username, net_settings.ip,net_settings.port) client_instance.connect(net_settings.username,
net_settings.ip, net_settings.port)
# net_settings.is_running = True # net_settings.is_running = True
drawer = draw.HUD(client_instance=client_instance) drawer = draw.HUD(client_instance=client_instance)
@ -293,7 +295,8 @@ class session_create(bpy.types.Operator):
global server global server
global client_instance global client_instance
server = subprocess.Popen(['python','server.py'], shell=False, stdout=subprocess.PIPE) server = subprocess.Popen(
['python', 'server.py'], shell=False, stdout=subprocess.PIPE)
time.sleep(0.1) time.sleep(0.1)
bpy.ops.session.join() bpy.ops.session.join()
@ -342,8 +345,10 @@ class session_stop(bpy.types.Operator):
class session_settings(bpy.types.PropertyGroup): class session_settings(bpy.types.PropertyGroup):
username = bpy.props.StringProperty( username = bpy.props.StringProperty(
name="Username", default="user_{}".format(randomStringDigits())) name="Username", default="user_{}".format(randomStringDigits()))
ip = bpy.props.StringProperty(name="ip", description='Distant host ip',default="127.0.0.1") ip = bpy.props.StringProperty(
port = bpy.props.IntProperty(name="port", description='Distant host port',default=5555) name="ip", description='Distant host ip', default="127.0.0.1")
port = bpy.props.IntProperty(
name="port", description='Distant host port', default=5555)
add_property_depth = bpy.props.IntProperty( add_property_depth = bpy.props.IntProperty(
name="add_property_depth", default=1) name="add_property_depth", default=1)
@ -409,9 +414,15 @@ classes = (
session_snapview, session_snapview,
) )
def ordered(updates): def ordered(updates):
# sorted = sorted(updates, key=lambda tup: SUPPORTED_TYPES.index(tup[1].id.bl_rna.name)) # sorted = sorted(updates, key=lambda tup: SUPPORTED_TYPES.index(tup[1].id.bl_rna.name))
uplist = [(SUPPORTED_TYPES.index(item[1].id.bl_rna.name),item[1].id.bl_rna.name,item[1].id.name) for item in updates.items()] uplist = []
for item in updates.items():
if item[1].id.bl_rna.name in SUPPORTED_TYPES:
uplist.append((SUPPORTED_TYPES.index(
item[1].id.bl_rna.name), item[1].id.bl_rna.name, item[1].id.name))
uplist.sort(key=itemgetter(0)) uplist.sort(key=itemgetter(0))
return uplist return uplist
@ -422,7 +433,7 @@ def is_dirty(updates):
if client_keys: if client_keys:
if len(client_keys) > 0: if len(client_keys) > 0:
for u in updates: for u in updates:
key = "{}/{}".format(u.id.bl_rna.name,u.id.name) key = "{}/{}".format(u.id.bl_rna.name, u.id.name)
if key not in client_keys: if key not in client_keys:
return True return True
@ -433,7 +444,7 @@ def is_dirty(updates):
def depsgraph_update(scene): def depsgraph_update(scene):
global client_instance global client_instance
if client_instance and client_instance.agent.is_alive(): if client_instance and client_instance.agent.is_alive():
updates = bpy.context.depsgraph.updates updates = bpy.context.depsgraph.updates
if is_dirty(updates): if is_dirty(updates):
@ -443,12 +454,13 @@ def depsgraph_update(scene):
elif update[1] in SUPPORTED_TYPES: elif update[1] in SUPPORTED_TYPES:
client_instance.set("{}/{}".format(update[1], update[2])) client_instance.set("{}/{}".format(update[1], update[2]))
if hasattr(bpy.context, 'selected_objects'):
if len(bpy.context.selected_objects)>0: if len(bpy.context.selected_objects) > 0:
updated_data = updates[0] updated_data = updates[0]
if updated_data.id.name == bpy.context.selected_objects[0].name: if updated_data.id.name == bpy.context.selected_objects[0].name:
if updated_data.is_updated_transform or updated_data.is_updated_geometry: if updated_data.is_updated_transform or updated_data.is_updated_geometry:
client_instance.set("{}/{}".format(updated_data.id.bl_rna.name, updated_data.id.name)) client_instance.set(
"{}/{}".format(updated_data.id.bl_rna.name, updated_data.id.name))
def register(): def register():
@ -481,8 +493,6 @@ def unregister():
del client_instance del client_instance
del client_keys del client_keys
from bpy.utils import unregister_class from bpy.utils import unregister_class
for cls in reversed(classes): for cls in reversed(classes):
unregister_class(cls) unregister_class(cls)
@ -490,5 +500,6 @@ def unregister():
del bpy.types.Scene.session_settings del bpy.types.Scene.session_settings
del bpy.types.ID.is_dirty del bpy.types.ID.is_dirty
if __name__ == "__main__": if __name__ == "__main__":
register() register()

2
server.py
View File

@ -88,7 +88,7 @@ class RCFServerAgent():
# Regular update routing (Clients / Client) # Regular update routing (Clients / Client)
elif self.collector_sock in socks: elif self.collector_sock in socks:
msg = message.RCFMessage.recv(self.collector_sock) msg = message.RCFMessage.recv(self.collector_sock)
logger.info("received object") # logger.info("received object")
# Update all clients # Update all clients
msg.store(self.property_map) msg.store(self.property_map)
msg.send(self.pub_sock) msg.send(self.pub_sock)