class ApiBridge(object):
def __init__(self):
# client = interop.Client(url='http://172.17.0.1:8000', username='******',password='******')
# missions = client.get_missions()
# print(missions)
# stationary_obstacles, moving_obstacles = client.get_obstacles()
# print(stationary_obstacles, moving_obstacles)
server = os.getenv('TEST_INTEROP_SERVER', 'http://localhost:8000')
username = os.getenv('TEST_INTEROP_USER', 'testuser')
password = os.getenv('TEST_INTEROP_USER_PASS', 'testpass')
admin_username = os.getenv('TEST_INTEROP_ADMIN', 'testadmin')
admin_password = os.getenv('TEST_INTEROP_ADMIN_PASS', 'testpass')
"""Create a logged in Client."""
# Create an admin client to clear cache.
self.admin_client = Client(server, admin_username, admin_password)
self.admin_client.get('/api/clear_cache')
# Test rest with non-admin clients.
self.client = Client(server, username, password)
self.async_client = AsyncClient(server, username, password)
def getObsta(self):
"""Test getting missions."""
async_future = self.async_client.get_obstacles()
async_stationary, async_moving = async_future.result()
return async_stationary, async_moving
def getMis(self):
"""Test getting missions."""
# missions = self.client.get_missions()
async_missions = self.async_client.get_missions().result()
return async_missions
class RelayService:
def __init__(self, url, username, password):
self.client = AsyncClient(url=url,
username=username,
password=password)
self.last_telemetry = time()
def telemetry(self, lat, lon, alt, heading):
t = Telemetry(latitude=lat,
longitude=lon,
altitude_msl=alt,
uas_heading=heading)
self.client.post_telemetry(t)
new_time = time()
print(1 / (new_time - self.last_telemetry))
self.last_telemetry = new_time
return True
def get_obstacles(self):
async_future = self.client.get_obstacles()
async_stationary, async_moving = async_future.result()
#print("here")
# stat_ob, moving_ob = self.client.get_obstacles()
async_radii_stationary = [o.cylinder_radius for o in async_stationary]
async_lat_stationary = [o.latitude for o in async_stationary]
async_lng_stationary = [o.longitude for o in async_stationary]
async_height_stationary = [o.cylinder_height for o in async_stationary]
async_radii_moving = [o.sphere_radius for o in async_moving]
async_lat_moving = [o.latitude for o in async_moving]
async_lng_moving = [o.longitude for o in async_moving]
async_height_moving = [o.altitude_msl for o in async_moving]
return async_radii_stationary, async_lat_stationary, async_lng_stationary, async_height_stationary, async_radii_moving, async_lat_moving, async_lng_moving, async_height_moving
def get_moving_obstacles(self):
return True
def server_info(self):
info = self.client.get_server_info().result()
return str(info.message), str(info.message_timestamp), str(info.server_time)
def main(url,
username,
password,
interop_time,
generator,
flightsim_kml_path=None):
"""Probes the interop server.
Args:
url: The interoperability URL.
username: The interoperability username.
password: The interoperability password.
interop_time: The time between interop requests.
generator: The data generator name to use.
flightsim_kml_path: The KML path to use if flightsim generator.
"""
# Create client and data generator.
client = AsyncClient(url, username, password)
if generator == 'zeros':
data_generator = datagen.ZeroValueGenerator()
else:
data_generator = flightsim.KmlGenerator(flightsim_kml_path)
# Continually execute interop requests until signaled to stop.
while True:
start_time = datetime.datetime.now()
telemetry = data_generator.get_uas_telemetry(start_time)
telemetry_resp = client.post_telemetry(telemetry)
obstacle_resp = client.get_obstacles()
telemetry_resp.result()
obstacle_resp.result()
end_time = datetime.datetime.now()
elapsed_time = (end_time - start_time).total_seconds()
logging.info('Executed interop. Total latency: %f', elapsed_time)
delay_time = interop_time - elapsed_time
if delay_time > 0:
try:
time.sleep(delay_time)
except KeyboardInterrupt:
sys.exit(0)
os.execvp("mavproxy.py", args)
#launch interop_cli.py in a new process
ic_pid = os.fork()
if (ic_pid == 0): #new process
args = [
"interop_cli.py", "--url", url, "--username", username, "--password",
password, "mavlink", "--device", mavlink_stream
]
os.execv("interop_cli.py", args)
exit(0)
#make sure the execed processes gets exited on ^c
def signal_handler(signal, frame):
os.kill(mp_pid, signal)
os.kill(ic_pid, signal)
exit(0)
signal.signal(signal.SIGINT, signal_handler)
client_instance = AsyncClient(url, username, password)
while (True):
obstacles = client_instance.get_obstacles()
#for type in obstacles.result(timeout=1):
#for obstacle in type:
#print obstacle
time.sleep(1)
# # Check one mission returned.
# self.assertEqual(1, len(missions))
# self.assertEqual(1, len(async_missions))
# # Check a few fields.
# self.assertTrue(missions[0].active)
# self.assertTrue(async_missions[0].active)
# self.assertEqual(1, missions[0].id)
# self.assertEqual(1, async_missions[0].id)
# self.assertEqual(38.14792, missions[0].home_pos.latitude)
# self.assertEqual(38.14792, async_missions[0].home_pos.latitude)
admin_client.get('/api/clear_cache')
"""Test getting obstacles."""
stationary, moving = client.get_obstacles()
async_future = async_client.get_obstacles()
async_stationary, async_moving = async_future.result()
# # No exceptions is a good sign, let's see if the data matches the fixture.
# self.assertEqual(2, len(stationary))
# self.assertEqual(2, len(async_stationary))
# self.assertEqual(1, len(moving))
# self.assertEqual(1, len(async_moving))
# # Lat, lon, and altitude of the moving obstacles change, so we don't
# # check those.
# self.assertEqual(50, moving[0].sphere_radius)
# self.assertEqual(50, async_moving[0].sphere_radius)
# radii = [o.cylinder_radius for o in stationary]
# async_radii = [o.cylinder_radius for o in async_stationary]
