def add_local_service(self, msg):
rosservprox = rospy.ServiceProxy(
msg.conn_name, get_ROS_class(msg.conn_type, srv=True))
l_to_r_srv_cv = self.create_callback_from_local_to_remote_srv(
msg.conn_name, msg.conn_type, rosservprox)
remote_service_server = self.client.service_server(
msg.alias_name, msg.conn_type, l_to_r_srv_cv)
self._instances['services'].append({
msg.conn_name: {
'rosservprox': rosservprox,
'bridgeservserver': remote_service_server
}
})
return ROSDuctConnectionResponse()
def add_remote_service(self, msg):
remote_service_client = self.client.service_client(
msg.conn_name, msg.conn_type)
r_to_l_serv_cb = self.create_callback_from_remote_to_local_srv(
remote_service_client, msg.conn_name, msg.conn_type)
rosserv = rospy.Service(msg.alias_name,
get_ROS_class(msg.conn_type, srv=True),
r_to_l_serv_cb)
self._instances['services'].append({
msg.conn_name: {
'rosserv': rosserv,
'bridgeservclient': remote_service_client
}
})
return ROSDuctConnectionResponse()
def add_local_topic(self, msg):
bridgepub = self.client.publisher(msg.alias_name,
msg.conn_type,
latch=msg.latch)
cb_l_to_r = self.create_callback_from_local_to_remote(
msg.conn_name, msg.conn_type, bridgepub)
rossub = rospy.Subscriber(msg.conn_name, get_ROS_class(msg.conn_type),
cb_l_to_r)
self._instances['topics'].append(
{msg.conn_name: {
'rossub': rossub,
'bridgepub': bridgepub
}})
return ROSDuctConnectionResponse()
def add_remote_topic(self, msg):
rospub = rospy.Publisher(
msg.alias_name,
get_ROS_class(msg.conn_type),
# SubscribeListener added later
queue_size=1,
latch=msg.latch)
cb_r_to_l = self.create_callback_from_remote_to_local(
msg.conn_name, msg.conn_type, rospub)
subl = self.create_subscribe_listener(msg.conn_name, msg.conn_type,
cb_r_to_l)
rospub.impl.add_subscriber_listener(subl)
self._instances['topics'].append(
{msg.conn_name: {
'rospub': rospub,
'bridgesub': None
}})
return ROSDuctConnectionResponse()
def initialize(self):
"""
Initialize creating all necessary bridged clients and servers.
"""
connected = False
while not rospy.is_shutdown() and not connected:
try:
self.client = ROSBridgeClient(self.rosbridge_ip,
self.rosbridge_port)
connected = True
except socket.error as e:
rospy.logwarn(
'Error when opening websocket, is ROSBridge running?')
rospy.logwarn(e)
rospy.sleep(5.0)
# We keep track of the instanced stuff in this dict
self._instances = {'topics': [], 'services': []}
for r_t in self.remote_topics:
if len(r_t) == 2:
topic_name, topic_type = r_t
local_name = topic_name
elif len(r_t) == 3:
topic_name, topic_type, local_name = r_t
rospub = rospy.Publisher(
local_name,
get_ROS_class(topic_type),
# SubscribeListener added later
queue_size=1)
cb_r_to_l = self.create_callback_from_remote_to_local(
topic_name, topic_type, rospub)
subl = self.create_subscribe_listener(topic_name, topic_type,
cb_r_to_l)
rospub.impl.add_subscriber_listener(subl)
self._instances['topics'].append(
{topic_name: {
'rospub': rospub,
'bridgesub': None
}})
for l_t in self.local_topics:
if len(l_t) == 2:
topic_name, topic_type = l_t
remote_name = topic_name
elif len(l_t) == 3:
topic_name, topic_type, remote_name = l_t
bridgepub = self.client.publisher(remote_name, topic_type)
cb_l_to_r = self.create_callback_from_local_to_remote(
topic_name, topic_type, bridgepub)
rossub = rospy.Subscriber(topic_name, get_ROS_class(topic_type),
cb_l_to_r)
self._instances['topics'].append(
{topic_name: {
'rossub': rossub,
'bridgepub': bridgepub
}})
# Services
for r_s in self.remote_services:
if len(r_s) == 2:
service_name, service_type = r_s
local_name = service_name
elif len(r_s) == 3:
service_name, service_type, local_name = r_s
remote_service_client = self.client.service_client(
service_name, service_type)
r_to_l_serv_cb = self.create_callback_from_remote_to_local_srv(
remote_service_client, service_name, service_type)
rosserv = rospy.Service(local_name,
get_ROS_class(service_type, srv=True),
r_to_l_serv_cb)
self._instances['services'].append({
service_name: {
'rosserv': rosserv,
'bridgeservclient': remote_service_client
}
})
for l_s in self.local_services:
if len(l_s) == 2:
service_name, service_type = l_s
remote_name = service_name
elif len(l_s) == 3:
service_name, service_type, remote_name = l_s
rosservprox = rospy.ServiceProxy(
service_name, get_ROS_class(service_type, srv=True))
l_to_r_srv_cv = self.create_callback_from_local_to_remote_srv(
service_name, service_type, rosservprox)
remote_service_server = self.client.service_server(
remote_name, service_type, l_to_r_srv_cv)
self._instances['services'].append({
service_name: {
'rosservprox': rosservprox,
'bridgeservserver': remote_service_server
}
})
# Get all params and store them for further updates
for param in self.parameters:
if type(param) == list:
# remote param name is the first one
param = param[0]
self.last_params[param] = self.client.get_param(param)
