def open(self):
cls = self.__class__
parameters = {
"fragment_timeout": cls.fragment_timeout,
"delay_between_messages": cls.delay_between_messages,
"max_message_size": cls.max_message_size,
"unregister_timeout": cls.unregister_timeout,
"bson_only_mode": cls.bson_only_mode
}
try:
self.protocol = RosbridgeProtocol(cls.client_id_seed,
parameters=parameters)
self.protocol.outgoing = self.send_message
self.set_nodelay(True)
self.authenticated = False
cls.client_id_seed += 1
cls.clients_connected += 1
if cls.client_count_pub:
cls.client_count_pub.publish(cls.clients_connected)
except Exception as exc:
rospy.logerr("Unable to accept incoming connection. Reason: %s",
str(exc))
rospy.loginfo("Client connected. %d clients total.",
cls.clients_connected)
if cls.authenticate:
rospy.loginfo("Awaiting proper authentication...")
def open(self):
cls = self.__class__
parameters = {
"fragment_timeout": cls.fragment_timeout,
"delay_between_messages": cls.delay_between_messages,
"max_message_size": cls.max_message_size,
"unregister_timeout": cls.unregister_timeout,
"bson_only_mode": cls.bson_only_mode
}
try:
self.protocol = RosbridgeProtocol(cls.client_id_seed, parameters=parameters)
self.protocol.outgoing = self.send_message
self.set_nodelay(True)
self.authenticated = False
self._write_lock = threading.RLock()
cls.client_id_seed += 1
cls.clients_connected += 1
self.client_id = uuid.uuid4()
if cls.client_manager:
cls.client_manager.add_client(self.client_id, self.request.remote_ip)
except Exception as exc:
rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc))
rospy.loginfo("Client connected. %d clients total.", cls.clients_connected)
if cls.authenticate:
rospy.loginfo("Awaiting proper authentication...")
def onOpen(self):
cls = self.__class__
parameters = {
"fragment_timeout": cls.fragment_timeout,
"delay_between_messages": cls.delay_between_messages,
"max_message_size": cls.max_message_size,
"unregister_timeout": cls.unregister_timeout,
"bson_only_mode": cls.bson_only_mode
}
try:
self.protocol = RosbridgeProtocol(cls.client_id_seed,
parameters=parameters)
producer = OutgoingValve(self)
self.transport.registerProducer(producer, True)
producer.resumeProducing()
self.protocol.outgoing = producer.relay
self.authenticated = False
cls.client_id_seed += 1
cls.clients_connected += 1
self.client_id = uuid.uuid4()
self.peer = self.transport.getPeer().host
if cls.client_manager:
cls.client_manager.add_client(self.client_id, self.peer)
except Exception as exc:
rospy.logerr("Unable to accept incoming connection. Reason: %s",
str(exc))
rospy.loginfo("Client connected. %d clients total.",
cls.clients_connected)
if cls.authenticate:
rospy.loginfo("Awaiting proper authentication...")
def setup(self):
cls = self.__class__
parameters = {
"port": cls.port,
"host": cls.host,
"incoming_buffer": cls.incoming_buffer,
"socket_timeout": cls.socket_timeout,
"retry_startup_delay": cls.retry_startup_delay,
"service_request_timeout": cls.service_request_timeout,
"check_response_delay": cls.check_response_delay,
"wait_for_busy_service_provider":
cls.wait_for_busy_service_provider,
"max_service_requests": cls.max_service_requests,
"fragment_timeout": cls.fragment_timeout,
"delay_between_messages": cls.delay_between_messages,
"max_message_size": cls.max_message_size
}
try:
self.protocol = RosbridgeProtocol(cls.client_id_seed,
parameters=parameters)
self.protocol.outgoing = self.send_message
cls.client_id_seed += 1
cls.clients_connected += 1
self.protocol.log(
"info",
"connected. " + str(cls.clients_connected) + " client total.")
except Exception as exc:
rospy.logerr("Unable to accept incoming connection. Reason: %s",
str(exc))
def test_setparam_service(self):
from rosbridge_library.rosbridge_protocol import RosbridgeProtocol
param = Param("/test_param")
test_protocol=RosbridgeProtocol(88)
def outgoing(message):
print("ROSBRidge Outgoing: {}".format(message))
test_protocol.outgoing=outgoing
test_protocol.incoming(param.set_command(885))
def test_sync(self):
with open('compressedDepth_sample_msg.txt', 'r') as outfile:
sample_depth = outfile.read()
with open('compressedRGB_sample_msg.txt', 'r') as outfile:
sample_rgb = outfile.read()
from rosbridge_library.rosbridge_protocol import RosbridgeProtocol
test_protocol = RosbridgeProtocol(88)
test_protocol.incoming(sample_depth)
test_protocol.incoming(sample_rgb)
def __init__(self, url):
self.url = url
parameters = {
"fragment_timeout": 600,
"delay_between_messages": 0,
"max_message_size": None,
"unregister_timeout": 10,
"bson_only_mode": False
}
self.ws = None
self.protocol = RosbridgeProtocol("main", parameters=parameters)
self.protocol.outgoing = self.send
def test_advertise_service(self):
from rosbridge_library.rosbridge_protocol import RosbridgeProtocol
test_protocol=RosbridgeProtocol(88)
def outgoing(message):
print("ROSBRidge Outgoing: {}".format(message))
test_protocol.incoming('{"op": "service_response", "service": "/test_service", "values": {"value": "88"}, "result": true, "id": "service_request:/test_service:1"}')
test_protocol.outgoing=outgoing
service = Service("/test_service",type="rosapi/GetParam")
test_protocol.incoming(service.advertise_command())
def onOpen(self):
global client_id_seed, clients_connected, authenticate, login
try:
self.protocol = RosbridgeProtocol(client_id_seed)
self.protocol.outgoing = self.send_message
self.authenticated = True
client_id_seed = client_id_seed + 1
clients_connected = clients_connected + 1
except Exception as exc:
rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc))
rospy.loginfo("Client connected. %d clients total.", clients_connected)
print("ROBOTCLIENT: Start websocket connection to server.")
self.Message = 'REGISTRATION:ROBOT|' + login
self.sendMessage(self.Message.encode('utf8'))
def test_rosbridge_false_subscription(self):
from std_msgs.msg import String
pub = rospy.Publisher("/test", String, queue_size=10,latch=True)
pub.publish("dada")
from rosbridge_library.rosbridge_protocol import RosbridgeProtocol
test_protocol=RosbridgeProtocol(88)
def outgoing(message):
print("ROSBRidge Outgoing: {}".format(message))
test_protocol.outgoing=outgoing
topic=Topic("/test","sensor_msgs/Image")
test_protocol.incoming(topic.advertise_command())
def __init__(self, id):
self._protocol = RosbridgeProtocol(id)
self._protocol.outgoing = self.rosbridge_outgoing
#Store whether to compress/decompress topics
self.incoming_topics_compression_state = {}
self.outgoing_topics_compression_state = {}
#Store whether to serialize/deserialize topics
self.topics_serialization_state = {}
#Store whether to remap topics/services
self.topics_remap_state = {}
self.services_remap_state = {}
self.inv_services_remap_state = {}
def open(self):
global client_id_seed, clients_connected, authenticate
try:
self.protocol = RosbridgeProtocol(client_id_seed)
self.protocol.outgoing = self.send_message
self.authenticated = False
client_id_seed = client_id_seed + 1
clients_connected = clients_connected + 1
except Exception as exc:
rospy.logerr("Unable to accept incoming connection. Reason: %s",
str(exc))
rospy.loginfo("Client connected. %d clients total.",
clients_connected)
if authenticate:
rospy.loginfo("Awaiting proper authentication...")
def open(self):
cls = self.__class__
try:
self.protocol = RosbridgeProtocol(cls.client_id_seed)
self.protocol.outgoing = self.send_message
self.set_nodelay(True)
self.authenticated = False
cls.client_id_seed += 1
cls.clients_connected += 1
except Exception as exc:
rospy.logerr("Unable to accept incoming connection. Reason: %s",
str(exc))
rospy.loginfo("Client connected. %d clients total.",
cls.clients_connected)
if cls.authenticate:
rospy.loginfo("Awaiting proper authentication...")
def test_rosbridgeprotocol(self):
from rosbridge_library.rosbridge_protocol import RosbridgeProtocol
test_protocol=RosbridgeProtocol(88)
def outgoing(message):
print("ROSBRidge Outgoing: {}".format(message))
test_protocol.outgoing=outgoing
with open('sample_config.json', 'r') as outfile:
sample_config = outfile.read()
parser = ConfigParser(sample_config)
commands = parser.parse()
test_protocol.incoming(commands[1])
def test_scan_topic(self):
with open('sample_scan.txt', 'r') as outfile:
sample_scan = outfile.read()
from rosbridge_library.rosbridge_protocol import RosbridgeProtocol
test_protocol = RosbridgeProtocol(88)
def outgoing(message):
print("ROSBRidge Outgoing: {}".format(message))
test_protocol.outgoing = outgoing
topic = Topic("/scan", "sensor_msgs/LaserScan", latch=False)
test_protocol.incoming(topic.advertise_command())
test_protocol.incoming(sample_scan)
def setup(self):
cls = self.__class__
parameters = {
"fragment_timeout": cls.fragment_timeout,
"delay_between_messages": cls.delay_between_messages,
"max_message_size": cls.max_message_size
}
try:
self.protocol = RosbridgeProtocol(cls.client_id_seed, parameters=parameters)
self.protocol.outgoing = self.send_message
cls.client_id_seed += 1
cls.clients_connected += 1
self.protocol.log("info", "connected. " + str(cls.clients_connected) + " client total.")
except Exception as exc:
rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc))
def startProtocol(self):
cls = self.__class__
parameters = {
"fragment_timeout": cls.fragment_timeout,
"delay_between_messages": cls.delay_between_messages,
"max_message_size": cls.max_message_size
}
try:
self.protocol = RosbridgeProtocol(cls.client_id_seed, parameters=parameters)
self.protocol.outgoing = self.send_message
self.authenticated = False
cls.client_id_seed += 1
cls.clients_connected += 1
except Exception as exc:
rospy.logerr("Unable to accept incoming connection. Reason: %s", str(exc))
rospy.loginfo("Client connected. %d clients total.", cls.clients_connected)
if cls.authenticate:
rospy.loginfo("Awaiting proper authentication...")
def test_service_handler(self):
from rosbridge_library.rosbridge_protocol import RosbridgeProtocol
test_protocol=RosbridgeProtocol(88)
service_handler=ServiceHandler(test_protocol)
def outgoing(message):
service_handler.callback(message)
print("ROSBRidge Outgoing: {}".format(message))
test_protocol.outgoing=outgoing
if not rospy.has_param("/test_param"):
rospy.set_param('/test_param', 88)
param = Param("/test_param")
result = yield service_handler.execute(param.get_command())
print("result is {}".format(result))
def main(args=None):
server_url = os.environ.get('ROWMA_SERVER_URL',
'https://rowma.moriokalab.com')
sio.connect(server_url)
signal.signal(signal.SIGINT, signal_handler)
signal.pause()
client_id_seed = 0
protocol = RosbridgeProtocol(client_id_seed, rowma)
protocol.outgoing = outgoing_func
rclpy.spin(rowma)
# Destroy the node explicitly
# (optional - otherwise it will be done automatically
# when the garbage collector destroys the node object)
rowma.destroy_node()
rclpy.shutdown()
def open(self):
cls = self.__class__
try:
from rosbridge_library.rosbridge_protocol import RosbridgeProtocol
self.protocol = RosbridgeProtocol(cls.client_id_seed)
self.protocol.outgoing = self.send_message
self.set_nodelay(True)
assert hasattr(cls, 'client_id_seed')
assert hasattr(cls, 'clients_connected')
except Exception as exc:
rospy.logerr(
'Unable to accept incoming connection. Reason: %s', str(exc))
self.close(code=PROTO_OPEN_FAILED, reason=str(exc))
return
cls.client_id_seed += 1
cls.clients_connected += 1
rospy.loginfo('Client connected. %d clients total.',
cls.clients_connected)
def open(self):
print("[BRIDGE]: open")
rospy.logwarn_once(
'The Tornado Rosbridge WebSocket implementation is deprecated.'
' See rosbridge_server.autobahn_websocket'
' and rosbridge_websocket.py')
cls = self.__class__
parameters = {
"fragment_timeout": cls.fragment_timeout,
"delay_between_messages": cls.delay_between_messages,
"max_message_size": cls.max_message_size,
"unregister_timeout": cls.unregister_timeout,
"bson_only_mode": cls.bson_only_mode
}
try:
self.protocol = RosbridgeProtocol(cls.client_id_seed,
parameters=parameters)
self.protocol.outgoing = self.send_message
self.set_nodelay(True)
self.authenticated = False
self._write_lock = threading.RLock()
cls.client_id_seed += 1
cls.clients_connected += 1
self.client_id = uuid.uuid4()
self.io_loop = IOLoop.current()
cls.clients[self.client_id] = (self.io_loop, self.close)
if cls.client_manager:
cls.client_manager.add_client(self.client_id,
self.request.remote_ip)
except Exception as exc:
rospy.logerr("Unable to accept incoming connection. Reason: %s",
str(exc))
rospy.loginfo("Client connected. %d clients total.",
cls.clients_connected)
if cls.authenticate:
rospy.loginfo("Awaiting proper authentication...")
def init(self):
self.ros_protocol = RosbridgeProtocol(0)
self.producer = OutgoingValve(self)
self.ros_protocol.outgoing = self.producer.relay
