class RosbridgeTcpSocket(SocketServer.BaseRequestHandler):
"""
TCP Socket server for rosbridge
"""
busy = False
queue = []
def setup(self):
global client_id_seed, clients_connected
parameters = {
"port": port,
"host": host,
"incoming_buffer": incoming_buffer,
"socket_timeout": socket_timeout,
"retry_startup_delay": retry_startup_delay,
"service_request_timeout": service_request_timeout,
"check_response_delay": check_response_delay,
"wait_for_busy_service_provider": wait_for_busy_service_provider,
"max_service_requests": max_service_requests,
"fragment_timeout": fragment_timeout,
"delay_between_messages": delay_between_messages,
"max_message_size": max_message_size
}
try:
self.protocol = RosbridgeProtocol(client_id_seed,
parameters=parameters)
self.protocol.outgoing = self.send_message
client_id_seed = client_id_seed + 1
clients_connected = clients_connected + 1
self.protocol.log(
"info",
"connected. " + str(clients_connected) + " client total.")
except Exception as exc:
logerr("Unable to accept incoming connection. Reason: %s",
str(exc))
def handle(self):
"""
Listen for TCP messages
"""
self.request.settimeout(socket_timeout)
while 1:
try:
data = self.request.recv(incoming_buffer)
# Exit on empty string
if data.strip() == '':
break
elif len(data.strip()) > 0:
#time.sleep(5)
self.protocol.incoming(data.strip(''))
else:
pass
except Exception, e:
pass
self.protocol.log(
"debug",
"socket connection timed out! (ignore warning if client is only listening..)"
)
class RosbridgeTcpSocket(SocketServer.BaseRequestHandler):
"""
TCP Socket server for rosbridge
"""
busy = False
queue = []
client_id_seed = 0
clients_connected = 0
# list of parameters
incoming_buffer = 65536 # bytes
socket_timeout = 10 # seconds
# The following are passed on to RosbridgeProtocol
# defragmentation.py:
fragment_timeout = 600 # seconds
# protocol.py:
delay_between_messages = 0 # seconds
max_message_size = None # bytes
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 handle(self):
"""
Listen for TCP messages
"""
cls = self.__class__
self.request.settimeout(cls.socket_timeout)
while 1:
try:
data = self.request.recv(cls.incoming_buffer)
# Exit on empty string
if data.strip() == '':
break
elif len(data.strip()) > 0:
self.protocol.incoming(data.strip(''))
else:
pass
except Exception, e:
pass
self.protocol.log("debug", "socket connection timed out! (ignore warning if client is only listening..)")
class RosbridgeTcpSocket(SocketServer.BaseRequestHandler):
"""
TCP Socket server for rosbridge
"""
busy = False
queue = []
def setup(self):
global client_id_seed, clients_connected
parameters = {
"port": port,
"host": host,
"incoming_buffer": incoming_buffer,
"socket_timeout": socket_timeout,
"retry_startup_delay": retry_startup_delay,
"service_request_timeout": service_request_timeout,
"check_response_delay": check_response_delay,
"wait_for_busy_service_provider": wait_for_busy_service_provider,
"max_service_requests": max_service_requests,
"fragment_timeout": fragment_timeout,
"delay_between_messages": delay_between_messages,
"max_message_size": max_message_size
}
try:
self.protocol = RosbridgeProtocol(client_id_seed, parameters = parameters)
self.protocol.outgoing = self.send_message
client_id_seed = client_id_seed + 1
clients_connected = clients_connected + 1
self.protocol.log("info", "connected. " + str(clients_connected) + " client total.")
except Exception as exc:
logerr("Unable to accept incoming connection. Reason: %s", str(exc))
def handle(self):
"""
Listen for TCP messages
"""
self.request.settimeout(socket_timeout)
while 1:
try:
data = self.request.recv(incoming_buffer)
# Exit on empty string
if data.strip() == '':
break
elif len(data.strip()) > 0:
#time.sleep(5)
self.protocol.incoming(data.strip(''))
else:
pass
except Exception, e:
pass
self.protocol.log("debug", "socket connection timed out! (ignore warning if client is only listening..)")
class RosbridgeTcpSocket(SocketServer.BaseRequestHandler):
"""
TCP Socket server for rosbridge
"""
busy = False
queue = []
client_id_seed = 0
clients_connected = 0
# list of possible parameters ( with internal default values
port = 9090 # integer (portnumber)
host = "" # hostname / IP as string
incoming_buffer = 65536 # bytes
socket_timeout = 10 # seconds
retry_startup_delay = 5 # seconds
# advertise_service.py:
service_request_timeout = 600 # seconds
check_response_delay = 0.01 # seconds
wait_for_busy_service_provider = 0.01 # seconds
max_service_requests = 1000000 # requests
# defragmentation.py:
fragment_timeout = 600 # seconds
# protocol.py:
delay_between_messages = 0.01 # seconds
max_message_size = None # bytes
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 handle(self):
"""
Listen for TCP messages
"""
cls = self.__class__
self.request.settimeout(cls.socket_timeout)
while 1:
try:
data = self.request.recv(cls.incoming_buffer)
# Exit on empty string
if data.strip() == '':
break
elif len(data.strip()) > 0:
self.protocol.incoming(data.strip(''))
else:
pass
except Exception, e:
pass
self.protocol.log(
"debug",
"socket connection timed out! (ignore warning if client is only listening..)"
)
class RosbridgeTcpSocket(SocketServer.BaseRequestHandler):
"""
TCP Socket server for rosbridge
"""
busy = False
queue = []
client_id_seed = 0
clients_connected = 0
# list of parameters
incoming_buffer = 65536 # bytes
socket_timeout = 10 # seconds
# The following are passed on to RosbridgeProtocol
# defragmentation.py:
fragment_timeout = 600 # seconds
# protocol.py:
delay_between_messages = 0 # seconds
max_message_size = None # bytes
bson_only_mode = False
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,
"bson_only_mode": cls.bson_only_mode
}
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 recvall(self, n):
# http://stackoverflow.com/questions/17667903/python-socket-receive-large-amount-of-data
# Helper function to recv n bytes or return None if EOF is hit
data = ''
while len(data) < n:
packet = self.request.recv(n - len(data))
if not packet:
return None
data += packet
return data
def recv_bson(self):
# Read 4 bytes to get the length of the BSON packet
BSON_LENGTH_IN_BYTES = 4
raw_msglen = self.recvall(BSON_LENGTH_IN_BYTES)
if not raw_msglen:
return None
msglen = struct.unpack('i', raw_msglen)[0]
# Retrieve the rest of the message
data = self.recvall(msglen - BSON_LENGTH_IN_BYTES)
if data == None:
return None
data = raw_msglen + data # Prefix the data with the message length that has already been received.
# The message length is part of BSONs message format
# Exit on empty message
if len(data) == 0:
return None
self.protocol.incoming(data)
return True
def handle(self):
"""
Listen for TCP messages
"""
cls = self.__class__
self.request.settimeout(cls.socket_timeout)
while 1:
try:
if self.bson_only_mode:
if self.recv_bson() == None:
break
continue
# non-BSON handling
data = self.request.recv(cls.incoming_buffer)
# Exit on empty string
if data.strip() == '':
break
elif len(data.strip()) > 0:
self.protocol.incoming(data.strip(''))
else:
pass
except Exception as e:
pass
self.protocol.log(
"debug",
"socket connection timed out! (ignore warning if client is only listening..)"
)
def finish(self):
"""
Called when TCP connection finishes
"""
cls = self.__class__
cls.clients_connected -= 1
self.protocol.finish()
self.protocol.log(
"info",
"disconnected. " + str(cls.clients_connected) + " client total.")
def send_message(self, message=None):
"""
Callback from rosbridge
"""
self.request.send(message)
class RosbridgeTcpSocket(SocketServer.BaseRequestHandler):
"""
TCP Socket server for rosbridge
"""
busy = False
queue = []
client_id_seed = 0
clients_connected = 0
# list of parameters
incoming_buffer = 65536 # bytes
socket_timeout = 10 # seconds
# The following are passed on to RosbridgeProtocol
# defragmentation.py:
fragment_timeout = 600 # seconds
# protocol.py:
delay_between_messages = 0 # seconds
max_message_size = None # bytes
unregister_timeout = 10.0 # seconds
bson_only_mode = False
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,
"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
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 recvall(self,n):
# http://stackoverflow.com/questions/17667903/python-socket-receive-large-amount-of-data
# Helper function to recv n bytes or return None if EOF is hit
data = ''
while len(data) < n:
packet = self.request.recv(n - len(data))
if not packet:
return None
data += packet
return data
def recv_bson(self):
# Read 4 bytes to get the length of the BSON packet
BSON_LENGTH_IN_BYTES = 4
raw_msglen = self.recvall(BSON_LENGTH_IN_BYTES)
if not raw_msglen:
return None
msglen = struct.unpack('i', raw_msglen)[0]
# Retrieve the rest of the message
data = self.recvall(msglen - BSON_LENGTH_IN_BYTES)
if data == None:
return None
data = raw_msglen + data # Prefix the data with the message length that has already been received.
# The message length is part of BSONs message format
# Exit on empty message
if len(data) == 0:
return None
self.protocol.incoming(data)
return True
def handle(self):
"""
Listen for TCP messages
"""
cls = self.__class__
self.request.settimeout(cls.socket_timeout)
while 1:
try:
if self.bson_only_mode:
if self.recv_bson() == None:
break
continue
# non-BSON handling
data = self.request.recv(cls.incoming_buffer)
# Exit on empty string
if data.strip() == '':
break
elif len(data.strip()) > 0:
self.protocol.incoming(data.strip(''))
else:
pass
except Exception as e:
pass
self.protocol.log("debug", "socket connection timed out! (ignore warning if client is only listening..)")
def finish(self):
"""
Called when TCP connection finishes
"""
cls = self.__class__
cls.clients_connected -= 1
self.protocol.finish()
self.protocol.log("info", "disconnected. " + str(cls.clients_connected) + " client total." )
def send_message(self, message=None):
"""
Callback from rosbridge
"""
self.request.sendall(message)
class RosbridgeTcpSocket(SocketServer.BaseRequestHandler):
"""
TCP Socket server for rosbridge
"""
busy = False
queue = []
client_id_seed = 0
clients_connected = 0
# list of possible parameters ( with internal default values
port = 9090 # integer (portnumber)
host = "" # hostname / IP as string
incoming_buffer = 65536 # bytes
socket_timeout = 10 # seconds
retry_startup_delay = 5 # seconds
# advertise_service.py:
service_request_timeout = 600 # seconds
check_response_delay = 0.01 # seconds
wait_for_busy_service_provider = 0.01 # seconds
max_service_requests = 1000000 # requests
# defragmentation.py:
fragment_timeout = 600 # seconds
# protocol.py:
delay_between_messages = 0.01 # seconds
max_message_size = None # bytes
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 handle(self):
"""
Listen for TCP messages
"""
cls = self.__class__
self.request.settimeout(cls.socket_timeout)
while 1:
try:
data = self.request.recv(cls.incoming_buffer)
# Exit on empty string
if data.strip() == '':
break
elif len(data.strip()) > 0:
self.protocol.incoming(data.strip(''))
else:
pass
except Exception, e:
pass
self.protocol.log("debug", "socket connection timed out! (ignore warning if client is only listening..)")