def _work(self): #Main method for connections
"""
Main loop.
1. Wait for a connection
2. Once connected, wait for commands from dronology
3. If connection interrupted, wait for another connection again.
4. Shut down when status is set to DEAD
:return:
"""
cont = True
while cont:
status = self.get_status()
if status == Connection._DEAD:
# Shut down
cont = False
elif status == Connection._WAITING:
# Try to connect, timeout after 10 seconds.
try:
sock = socket.create_connection((self._addr, self._port),
timeout=5.0)
self._sock = socketutils.BufferedSocket(sock)
handshake = json.dumps({
'type': 'connect',
'uavid': self._g_id
})
self._sock.send(handshake) #Sends the JSON message
self._sock.send(os.linesep)
self.set_status(
Connection._CONNECTED
) # No exception occurred, so its connected
except socket.error as e:
#_LOG.info('Socket error ({})'.format(e))
print "socket error"
print e
time.sleep(10.0)
else: #_CONNECTED
# Receive messages
try:
msg = self._sock.recv_until(os.linesep, timeout=0.1)
self._msgs.put_message(msg)
except socket.timeout:
pass
except socket.error as e:
#_LOG.warn('connection interrupted! ({})'.format(e))
print "connection interrupted"
self._sock.shutdown(socket.SHUT_RDWR)
self._sock.close()
self._sock = None
self.set_status(Connection._WAITING)
time.sleep(20.0)
if self._sock is not None:
#_LOG.info('Shutting down socket.')
print "Shutting down socket"
self._sock.shutdown(socket.SHUT_WR)
#_LOG.info('Closing socket.')
print "Closing socket"
self._sock.close()
return
def connectTo(self, address, port):
try:
sock = socket.create_connection((address, port), timeout=5.0)
self._sock = socketutils.BufferedSocket(sock)
print(">>> Connected to lead vehicle " + address + " on port " +
str(port))
except socket.error as e:
print('-Socket error ({})'.format(e))
print(e)
time.sleep(10.0)
def createConnection(self, port):
try:
serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serv.bind(('0.0.0.0', port))
print(">>> Opening connection on port " + str(port))
serv.listen(5)
conn, addr = serv.accept()
print(">>> Connection established")
self._sock = socketutils.BufferedSocket(conn)
while True:
msg = self._sock.recv_until(os.linesep, timeout=50)
print("RECEIVED: " + msg)
self.callback.handleMessage(msg)
except socket.error as e:
print('>Socket error ({})'.format(e))
time.sleep(10.0)
def connect(self):
"""
Connect to the Lightpack API.
A CannotConnectError is raised on failure.
"""
# Function to run if we fail
def fail(cause=None):
raise CannotConnectError("Could not connect to %s:%d (%s an API key)" % ( \
self.host, \
self.port, \
"without" if self.api_key is None else "with"), \
cause)
# Attempt to connect
try:
connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connection.connect((self.host, self.port))
self.connection = socketutils.BufferedSocket(connection)
greeting = self._readResult()
except Exception as e:
fail(e)
# Check greeting and reported API version
match = re.findall(r'API v?(\d+(?:\.\d+)?)', greeting)
if match:
match.sort(reverse=True)
self._apiVersion = StrictVersion(match[0])
if self._apiVersion < API_VERSION_GTE or self._apiVersion > \
API_VERSION_LTE:
fail("API version (%s) is not supported" % self._apiVersion)
else:
fail("Unrecognized greeting from server: \"%s\"" % greeting)
# Give API key if we have one
if self.api_key is not None:
response = self._sendAndReceive('apikey:%s' % self.api_key)
if response != 'ok':
fail("bad API key (server responded '%s')" % response)
def main_loop(self):
raw_sock = socket.socket()
raw_sock.connect((self.host_addr, self.host_port))
print('connected')
buf_sock = socketutils.BufferedSocket(raw_sock,
timeout=TIMEOUT,
maxsize=1024 * 16)
try:
assert MAGIC_INIT_BYTES == buf_sock.recv_size(
size=len(MAGIC_INIT_BYTES), timeout=None)
model_size = recv_int(buf_sock)
print('model size:', model_size)
model_bytes = buf_sock.recv_size(size=model_size, timeout=TIMEOUT)
print('model recieved')
model_file = open('current_model.h5', 'wb')
model_file.write(model_bytes)
model_file.close()
self.model = load_model('current_model.h5')
while True:
print('wait task')
head_bytes = buf_sock.recv_size(size=len(MAGIC_BYTES),
timeout=None)
print('new task')
assert head_bytes == MAGIC_BYTES
img_url = recv_str(buf_sock)
img = downloadToImage(img_url)
is_img_cat = is_cat(img, self.model)
print('Result: {} is {} URL'.format(
img_url, 'cat' if is_img_cat else 'dog'))
buf_sock.sendall(b'1' if is_img_cat else b'0', timeout=TIMEOUT)
except socketutils.ConnectionClosed:
print('Connection is closed, tear down')
finally:
buf_sock.close()
