autoverse-cli 0.11.0__tar.gz → 0.12.1__tar.gz

{autoverse_cli-0.11.0 → autoverse_cli-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: autoverse-cli
-Version: 0.11.0
+Version: 0.12.1
 Summary: The Autoverse CLI
 Author-email: Dan Kamrath <dan.kamrath@autonomalabs.com>
 License: # End-User License Agreement (EULA) of the Autonoma AutoVerse CLI

{autoverse_cli-0.11.0 → autoverse_cli-0.12.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "autoverse-cli"
-version = "0.11.0"
+version = "0.12.1"
 dependencies = [
   "boto3",
   "cantools"

{autoverse_cli-0.11.0 → autoverse_cli-0.12.1}/src/autoverse_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: autoverse-cli
-Version: 0.11.0
+Version: 0.12.1
 Summary: The Autoverse CLI
 Author-email: Dan Kamrath <dan.kamrath@autonomalabs.com>
 License: # End-User License Agreement (EULA) of the Autonoma AutoVerse CLI

{autoverse_cli-0.11.0 → autoverse_cli-0.12.1}/src/autoverse_cli.egg-info/SOURCES.txt

@@ -16,12 +16,17 @@ src/avrs/can_tool_util.py
 src/avrs/cfg.py
 src/avrs/launcher.py
 src/avrs/launcher_util.py
+src/avrs/race_cloud.py
+src/avrs/race_cloud_cfg_util.py
+src/avrs/race_cloud_util.py
 src/avrs/simconfig.py
 src/avrs/simconfig_util.py
 src/avrs/tests.py
+src/avrs/util.py
 src/avrs/requests/change_camera.py
 src/avrs/requests/code_booz.py
 src/avrs/requests/demo.py
+src/avrs/requests/dump_sim_config.py
 src/avrs/requests/environment.py
 src/avrs/requests/fault_injection.py
 src/avrs/requests/get_object_config.py
@@ -31,7 +36,6 @@ src/avrs/requests/misc.py
 src/avrs/requests/move_to_landmark.py
 src/avrs/requests/npc.py
 src/avrs/requests/request.py
-src/avrs/requests/reserve_mv_slot.py
 src/avrs/requests/reset_to_track.py
 src/avrs/requests/restart.py
 src/avrs/requests/scenario_control.py

{autoverse_cli-0.11.0 → autoverse_cli-0.12.1}/src/avrs/app_version.py

@@ -2,7 +2,7 @@ import http.client
 import json
 
 def get_app_version():
-    return '0.11.0'
+    return '0.12.1'
 
 def check_app_is_latest():
     pass

{autoverse_cli-0.11.0 → autoverse_cli-0.12.1}/src/avrs/avrs.py

@@ -7,6 +7,7 @@ from avrs.app_version import *
 from avrs.cfg import *
 from avrs.launcher import *
 from avrs.can_tool import *
+from avrs.race_cloud import *
 from avrs.argparse_help import *
 
 from avrs.requests.move_to_landmark import MoveToLandmarkRequest
@@ -14,7 +15,6 @@ from avrs.requests.restart import Restart
 from avrs.requests.reset_to_track import ResetToTrack
 from avrs.requests.teleport import Teleport
 from avrs.requests.npc import Npc
-from avrs.requests.reserve_mv_slot import ReserveMvSlot
 from avrs.requests.vd import Vd
 from avrs.requests.vehicle_input import AvrsConfigureVehicleInputRequest
 from avrs.requests.log_path import LogPath
@@ -31,6 +31,7 @@ from avrs.simconfig import *
 from avrs.requests.get_object_config import *
 from avrs.requests.misc import *
 from avrs.requests.spawn_object import *
+from avrs.requests.dump_sim_config import *
 
 
 def get_version():
@@ -67,7 +68,7 @@ def main():
     ResetToTrack(sps, cfg)
     Teleport(sps, cfg)
     #Npc(sps, cfg)
-    #ReserveMvSlot(sps, cfg)
+    AvrsRaceCloud(sps, cfg)
     Vd(sps, cfg)
     AvrsConfigureVehicleInputRequest(sps, cfg)
     LogPath(sps, cfg)
@@ -86,6 +87,7 @@ def main():
     AvrsPingRequest(sps, cfg)
     AvrsConfigureSimLodRequest(sps, cfg)
     AvrsSpawnObjectRequest(sps, cfg)
+    AvrsDumpSimConfigRequest(sps, cfg)
 
     if os.environ.get('AVRS_WITH_DEMO', '0') == '1':
         AvrsDemoRequest(sps, cfg)

autoverse_cli-0.12.1/src/avrs/race_cloud.py

@@ -0,0 +1,296 @@
+import subprocess
+import base64
+from avrs.cfg import *
+from avrs.race_cloud_util import *
+from avrs.race_cloud_cfg_util import *
+from avrs.util import *
+from avrs.requests.request import AvrsApiRequest
+from argparse import RawTextHelpFormatter
+
+class AvrsRaceCloud(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        self.cfg = cfg
+        race_cloud_parser = parser.add_parser(
+            'race-cloud', 
+            help='cloud racing\n\n')
+
+        sps = race_cloud_parser.add_subparsers(required=True, help='race-cloud options')
+
+        connect_parser = sps.add_parser(
+            'connect',
+            help='connect to an instance for cloud racing')
+        connect_parser.add_argument(
+            'sim_index',
+            type = int,
+            choices = [0, 1, 2, 3, 4, 5],
+            help='the index of the simulator instance to connect to')
+        connect_parser.add_argument(
+            'team_name',
+            help='the name of the team to race under')
+        connect_parser.add_argument(
+            'vehicle_config',
+            help='the path the vehicle configuration file to use when racing')
+        connect_parser.add_argument(
+            '--instance-id',
+            default = '',
+            help='can be used directly instead of instance name if needed')
+        connect_parser.add_argument(
+            '--no-check-cans',
+            action='store_true',
+            help='if set, vcan interfaces will not be checked for validity')
+        connect_parser.set_defaults(func=self.race_connect)
+
+        rx_connect_parser = sps.add_parser(
+            'rx-connection',
+            help='execute steps to receive a connection (only relevant to sim-side)')
+        rx_connect_parser.add_argument(
+            'team_name',
+            help='the name of the connecting team')
+        rx_connect_parser.add_argument(
+            'ip',
+            help='the ip address of the incoming connection')
+        rx_connect_parser.add_argument(
+            'cfg_data',
+            help='the incoming vehicle configuration data')
+        rx_connect_parser.set_defaults(func=self.rx_connect)
+
+        sim_ctrl_parser = sps.add_parser(
+            'sim-ctrl',
+            help='control the sim program (start, stop, restart, reset)')
+        sim_ctrl_parser.add_argument(
+            'sim_index',
+            type=int,
+            choices=[0, 1, 2, 3, 4, 5],
+            help='the index of the simulator instance to apply the action')
+        sim_ctrl_parser.add_argument(
+            'action',
+            choices=['start', 'stop', 'restart', 'reset-connection'],
+            help='what action to apply to the simulator program')
+        sim_ctrl_parser.add_argument(
+            '--local',
+            action='store_true',
+            help='if set, this command will run on this system locally (not for use from dev instances)')
+        sim_ctrl_parser.add_argument(
+            '--instance-id',
+            default = '',
+            help='can be used directly instead of sim index if needed')
+        sim_ctrl_parser.add_argument(
+            '--clear-autospawns',
+            action='store_true',
+            help='can be used with the reset-connection action to clear sim autospawn config')
+        sim_ctrl_parser.set_defaults(func=self.sim_ctrl)
+
+        reset_qos_parser = sps.add_parser(
+            'reset-qos',
+            help='reset the qos file on this system')
+        reset_qos_parser.set_defaults(func=self.reset_qos)
+
+        enable_peer_qos_parser = sps.add_parser(
+            'enable-peer-qos',
+            help='enable a peer in this systems qos file')
+        enable_peer_qos_parser.add_argument(
+            'peer_id',
+            type=int,
+            choices=[0, 1, 2, 3, 4, 5],
+            help='the id of the peer to enable')
+        enable_peer_qos_parser.add_argument(
+            'ip',
+            help='the ip address to add to the qos file')
+        enable_peer_qos_parser.set_defaults(func=self.enable_peer_qos)
+
+        disable_peer_qos_parser = sps.add_parser(
+            'disable-peer-qos',
+            help='disable a peer in this systems qos file')
+        disable_peer_qos_parser.add_argument(
+            'peer_id',
+            type=int,
+            choices=[0, 1, 2, 3, 4, 5],
+            help='the id of the peer to enable')
+        disable_peer_qos_parser.set_defaults(func=self.disable_peer_qos)
+
+
+    def race_connect(self, args):
+        print('connecting to race with team name: {}'.format(args.team_name))
+
+        # validate / load vehicle config
+
+        vcfg_ok, vcfg_data, bsu_vcan, kistler_vcan, badenia_vcan = prepare_vehicle_cfg(args.vehicle_config)
+
+        if not vcfg_ok:
+            print('error sending config file: {}'.format(vcfg_data))
+            return
+
+        vcan_ok = True
+        if not check_vcan_exists(bsu_vcan) and not args.no_check_cans:
+            print('bsu vcan {} does not appear to exist'.format(bsu_vcan))
+            vcan_ok = False
+        if not check_vcan_exists(kistler_vcan) and not args.no_check_cans:
+            print('kistler vcan {} does not appear to exist'.format(kistler_vcan))
+            vcan_ok = False
+        if not check_vcan_exists(badenia_vcan) and not args.no_check_cans:
+            print('badenia vcan {} does not appear to exist'.format(badenia_vcan))
+            vcan_ok = False
+
+        if not vcan_ok:
+            return
+
+        # make api call to begin connection
+        our_ip = get_local_instance_ip()
+
+        connection_request = {
+            'action': 'connect',
+            'sim_index': args.sim_index,
+            'ip_to_reserve': our_ip,
+            'team_name': args.team_name,
+            'sim_id_override': args.instance_id,
+            'ensure_instance_is_running': False,
+            'config_data': vcfg_data
+        }
+
+        ok, response = call_race_cloud_api(connection_request)
+        if not ok:
+            print('connect api error: {}'.format(response))
+
+        ok, rbody, sim_ip = get_api_script_response(response)
+        if not ok:
+            print(rbody)
+            return
+
+        print(rbody)
+        #print(sim_ip)
+
+        slot_info = {}
+        for k, v in rbody.items():
+            #print('out: {}'.format(v['stdout']))
+            #print('err: {}'.format(v['stderr']))
+            slot_info = json.loads(v['stdout'])
+
+        if not slot_info['ok']:
+            print('issue reserving slot: {}'.format(slot_info['msg']))
+            return
+
+        sim_slot = slot_info['slot']
+
+        # enable first peer since this is on a client (only will ever have 1, the sim)
+        enable_peer_qos(sim_slot, sim_ip)
+
+        # will need to get port from received slot id to connect peer vcans
+        connect_peer_vcan(sim_slot, sim_ip, 0, bsu_vcan)
+        connect_peer_vcan(sim_slot, sim_ip, 1, kistler_vcan)
+        connect_peer_vcan(sim_slot, sim_ip, 2, badenia_vcan)
+
+        # configure the CLI to communicate with the cloud sim instance
+        self.cfg['sim_address'] = sim_ip
+        save_cfg('avrs', self.cfg)
+
+        print('connection success with team name {} and slot id {}'.format(args.team_name, sim_slot))
+
+    # this should only run on sim instances (not dev instances)
+    def rx_connect(self, args):
+        ok, msg, slot = try_get_open_slot(args.team_name, args.ip)
+
+        bsu_vcan = get_auto_vcan_name(slot, 0)
+        kistler_vcan = get_auto_vcan_name(slot, 1)
+        badenia_vcan = get_auto_vcan_name(slot, 2)
+
+        # get CAN names from this
+        register_received_vehicle(
+            args.team_name, slot, args.cfg_data, bsu_vcan, kistler_vcan, badenia_vcan)
+
+        vcan_ok = True
+        vcan_msg = ''
+        if not check_vcan_exists(bsu_vcan):
+            vcan_msg = 'bsu vcan {} does not appear to exist'.format(bsu_vcan)
+            vcan_ok = False
+        if not check_vcan_exists(kistler_vcan):
+            vcan_msg = 'kistler vcan {} does not appear to exist'.format(kistler_vcan)
+            vcan_ok = False
+        if not check_vcan_exists(badenia_vcan):
+            vcan_msg = 'badenia vcan {} does not appear to exist'.format(badenia_vcan)
+            vcan_ok = False
+
+        if not vcan_ok:
+            print(json.dumps({
+                'ok': vcan_ok,
+                'msg': vcan_msg,
+                'slot': -1
+                }))
+            return
+
+        if ok:
+            enable_peer_qos(slot, args.ip)
+            connect_peer_vcan(slot, args.ip, 0)
+            connect_peer_vcan(slot, args.ip, 1)
+            connect_peer_vcan(slot, args.ip, 2)
+
+        response = {
+            'ok': ok,
+            'msg': msg,
+            'slot': slot
+        }
+
+        print(json.dumps(response)) # print this so that when called from the ssh lambda we can get the result
+
+    def sim_ctrl(self, args):
+        if args.local:
+            self.local_sim_ctrl(args)
+        else:
+            self.remote_sim_ctrl(args)
+
+    def local_sim_ctrl(self, args):
+        if args.action == 'reset-connection':
+            print('resetting race cloud connection')
+            print('resetting qos file, removing CAN lock files, stopping all cannelloni instances')
+            reset_race_cloud_connection()
+            if args.clear_autospawns:
+                clear_autospawns()
+        if args.action == 'stop' or args.action == 'restart':
+            print('stopping sim program on sim instance {}'.format(args.sim_index))
+            bash_kill_process('Autoverse')
+        if args.action == 'start' or args.action == 'restart':
+            print('starting sim program on sim instance {}'.format(args.sim_index))
+            exe_path = os.path.join(get_sim_install_path(), 'Linux', 'Autoverse.sh')
+            start_exe(exe_path)
+
+    def remote_sim_ctrl(self, args):
+
+        # go ahead and reset local connection as well
+        if args.action == 'reset-connection':
+            reset_race_cloud_connection()
+
+        our_ip = get_local_instance_ip()
+
+        reset_request = {
+            'action': args.action,
+            'sim_index': args.sim_index,
+            'ip_to_reserve': our_ip,
+            'sim_id_override': args.instance_id,
+            'ensure_instance_is_running': False
+        }
+
+        ok, response = call_race_cloud_api(reset_request)
+        #print(response)
+        if not ok:
+            print(response)
+            return
+
+        ok, rbody, sim_ip = get_api_script_response(response)
+        if not ok:
+            print(rbody)
+            return
+
+        for k, v in rbody.items():
+            print(v['stdout'])
+
+    def reset_qos(self, args):
+        print('resetting qos file')
+        reset_rmw_qos()
+
+    def enable_peer_qos(self, args):
+        print('enabling peer qos for id {} using ip address {}'.format(
+            args.peer_id, args.ip))
+        enable_peer_qos(args.peer_id, args.ip)
+
+    def disable_peer_qos(self, args):
+        print('disabling peer qos for id {}'.format(args.peer_id))
+        disable_peer_qos(args.peer_id)

autoverse_cli-0.12.1/src/avrs/race_cloud_cfg_util.py

@@ -0,0 +1,106 @@
+import os
+import json
+import base64
+
+from avrs.simconfig_util import *
+
+def get_payload(cfg_object, payload_name):
+	for p in cfg_object['payloads']:
+		if p['typeName'] == payload_name:
+			return p
+	return None
+
+def clear_autospawns():
+	# also need to edit the yas_marina_env.json to have autospawn for this config
+	sim_path = os.environ.get('AVRS_INSTALL_PATH', 
+		os.path.join(os.environ['HOME'], 'autoverse-linux'))
+	sim_saved = os.path.join(sim_path, 'Linux', 'Autoverse', 'Saved')
+	cfg_files = SimConfigFiles(sim_saved)
+
+	cfg_ok, msg = cfg_files.validate()
+	if not cfg_ok:
+		print(msg)
+		return
+
+	cfg_files.files['yas']['autoSpawnObjects'] = []
+	cfg_files.save()
+
+def register_received_vehicle(team_name, slot, cfg_data, bsu_vcan, kistler_vcan, badenia_vcan):
+	cfg_string = base64.b64decode(cfg_data)
+	cfg_object = json.loads(cfg_string.decode('utf-8'))
+
+	# ensure perception is disabled
+	eav24 = get_payload(cfg_object, 'Eav24Initializer')
+	if eav24 is None:
+		return (False, 'no eav24 payload found')
+
+	eav24['body']['bLidarEnabled'] = False
+	eav24['body']['bCameraEnabled'] = False
+	eav24['body']['bRadarEnabled'] = False
+	eav24['body']['bPublishGroundTruth'] = False
+	eav24['body']['bPublishInputs'] = False
+	eav24['body']['bsuCanName'] = bsu_vcan
+	eav24['body']['kistlerCanName'] = kistler_vcan
+	eav24['body']['badeniaCanName'] = badenia_vcan
+
+	# do not allow default object name (collision)
+	if cfg_object['name'] == 'eav24':
+		cfg_object['name'] = team_name
+	cfg_object['specName'] = 'eav24_{}'.format(team_name)
+
+	# also need to edit the yas_marina_env.json to have autospawn for this config
+	sim_path = os.environ.get('AVRS_INSTALL_PATH', 
+		os.path.join(os.environ['HOME'], 'autoverse-linux'))
+	sim_saved = os.path.join(sim_path, 'Linux', 'Autoverse', 'Saved')
+	cfg_files = SimConfigFiles(sim_saved)
+
+	cfg_ok, msg = cfg_files.validate()
+	if not cfg_ok:
+		print(msg)
+		return
+
+	start_landmark = 'MvStart{}'.format(slot)
+
+	entry_exists = False
+	for i in cfg_files.files['yas']['autoSpawnObjects']:
+		if 'objectSpec' in i and i['objectSpec'] == cfg_object['specName']:
+			entry_exists = True
+
+	if not entry_exists:
+		cfg_files.files['yas']['autoSpawnObjects'].append({
+				'bShouldSpawn': True,
+				'objectType': 'Eav24',
+				'objectSpec': cfg_object['specName'],
+				'bSpawnAtLandmark': True,
+				'spawnLandmarkName': start_landmark
+			})
+		cfg_files.save()
+
+	target_path = os.path.join(os.environ['HOME'], 'test_cfg.json')
+	with open(target_path, 'w', encoding='utf-8') as f:
+		json.dump(cfg_object, f, ensure_ascii=False, indent=4)
+
+def prepare_vehicle_cfg(cfg_path):
+
+	#print('preparing config for transmission: {}'.format(cfg_path))
+
+	if not os.path.isfile(cfg_path):
+		return (False, '{} is not a valid file'.format(cfg_path))
+
+	cfg_object = {}
+	with open(cfg_path, 'r', encoding='utf-8') as f:
+		cfg_object = json.load(f)
+
+
+	# obtain desired CAN names to start cannelloni
+	eav24 = get_payload(cfg_object, 'Eav24Initializer')
+	if eav24 is None:
+		return (False, 'no eav24 payload found')
+
+	bsu_vcan = eav24['body']['bsuCanName']
+	kistler_vcan = eav24['body']['kistlerCanName']
+	badenia_vcan = eav24['body']['badeniaCanName']
+
+	cfg_data = base64.b64encode(json.dumps(cfg_object).encode('utf-8')).decode('utf-8')
+	return (True, cfg_data, bsu_vcan, kistler_vcan, badenia_vcan)
+

autoverse_cli-0.12.1/src/avrs/race_cloud_util.py

@@ -0,0 +1,237 @@
+import os
+import json
+import http.client
+from avrs.util import *
+
+BASH_KILL_PROCESS_SCRIPT = '''
+    PROC_NAME={pname}
+    I=0
+    TRIES=20
+    while [ $I -le $TRIES ]; do
+
+        pkill $PROC_NAME
+        PROC_RUNNING=$(ps -A | grep $PROC_NAME)
+        if [[ ! -z $PROC_RUNNING ]]; then
+            echo process $PROC_NAME is still running
+            if [ $I == $(( TRIES - 1 )) ]; then
+                echo process is resisting. crushing its dreams with sigkill
+                pkill -SIGKILL $PROC_NAME
+            fi
+        else
+            echo process $PROC_NAME is not running
+            break
+        fi
+        I=$(( I + 1 ))
+        sleep 1
+    done
+'''
+
+DEFAULT_RMW_QOS = '''
+<?xml version="1.0" encoding="UTF-8" ?>
+<profiles xmlns="http://www.eprosima.com/XMLSchemas/fastRTPS_Profiles">
+    <transport_descriptors>
+        <transport_descriptor>
+            <transport_id>morepeers</transport_id> <!-- string -->
+            <type>UDPv4</type> <!-- string -->
+            <maxInitialPeersRange>100</maxInitialPeersRange> <!-- uint32 -->
+        </transport_descriptor>
+    </transport_descriptors>
+    <participant profile_name="participant_profile_ros2" is_default_profile="true">
+        <rtps>
+            <builtin>
+                <metatrafficUnicastLocatorList>
+                    <locator/>
+                </metatrafficUnicastLocatorList>
+                <initialPeersList>
+                    <locator> <udpv4> <address>127.0.0.1</address> </udpv4> </locator>
+                    <!--<locator> <udpv4> <address>PEER_0</address> </udpv4> </locator>PEER0-->
+                    <!--<locator> <udpv4> <address>PEER_1</address> </udpv4> </locator>PEER1-->
+                    <!--<locator> <udpv4> <address>PEER_2</address> </udpv4> </locator>PEER2-->
+                    <!--<locator> <udpv4> <address>PEER_3</address> </udpv4> </locator>PEER3-->
+                    <!--<locator> <udpv4> <address>PEER_4</address> </udpv4> </locator>PEER4-->
+                    <!--<locator> <udpv4> <address>PEER_5</address> </udpv4> </locator>PEER5-->
+                </initialPeersList>
+            </builtin>
+            <userTransports>
+            <transport_id>morepeers</transport_id>
+            </userTransports>
+            <useBuiltinTransports>false</useBuiltinTransports>
+        </rtps>
+    </participant>
+</profiles>
+'''
+
+DISABLE_PEER_QOS_SCRIPT = '''
+    QOS_FILE_PATH={qos_path}
+    PEER_ID={peer_id}
+    sed -i -E "s,(<locator> <udpv4> <address>)(.+)(</address> </udpv4> </locator>)<!--(PEER$PEER_ID-->),<!--\\1PEER$PEER_ID\\3\\4,g" $QOS_FILE_PATH
+
+    VCAN_NAME=vcan$PEER_ID
+    if [[ -e $VCAN_NAME.lock ]]; then
+        echo "stopping existing cannelloni connection with pid $(cat $VCAN_NAME.lock)"
+        kill $(cat $VCAN_NAME.lock)
+        rm $VCAN_NAME.lock
+    fi
+'''
+
+ENABLE_PEER_QOS_SCRIPT = '''
+    QOS_FILE_PATH={qos_path}
+    PEER_ID={peer_id}
+    PEER_ADDRESS={peer_ip}
+    sed -i -E "s,(<!--?)(<locator> <udpv4> <address>)(.+)(</address> </udpv4> </locator>)(PEER$PEER_ID-->),\\2$PEER_ADDRESS\\4<!--\\5,g" $QOS_FILE_PATH
+'''
+
+CONNECT_PEER_VCAN_SCRIPT = '''
+    PEER_ID={peer_id}
+    PEER_ADDRESS={peer_ip}
+    REMOTE_PORT={remote_port}
+    LOCAL_PORT={local_port}
+    VCAN_NAME={vcan_name}
+    LOCK_FILE=$HOME/.$VCAN_NAME.lock
+    LOG_FILE="$HOME/.$VCAN_NAME.log"
+    if [[ -z $VCAN_NAME ]]; then
+        VCAN_NAME=vcan$PEER_ID
+    fi
+    echo "connecting peer id $PEER_ID using local port $LOCAL_PORT and remote port $REMOTE_PORT and vcan name $VCAN_NAME"
+
+    if [[ -e $LOCK_FILE ]]; then
+        echo "stopping existing cannelloni connection with pid $(cat $LOCK_FILE)"
+        kill $(cat $LOCK_FILE)
+    fi
+
+    # https://stackoverflow.com/questions/29142/getting-ssh-to-execute-a-command-in-the-background-on-target-machine
+    # nohup to avoid SSH issues, send stdout to loni.log, send stderr to stdout, dont expect input, and background with "&"
+    nohup cannelloni -I $VCAN_NAME -R $PEER_ADDRESS -r $REMOTE_PORT -l $LOCAL_PORT >"$LOG_FILE" 2>&1 < /dev/null &
+    echo "$!" > $LOCK_FILE
+'''
+
+CHECK_VCAN_EXISTS_SCRIPT = '''
+    if [[ -z $(ip addr show | grep {vcan_name}) ]]; then
+        echo -n "no"
+    else
+        echo -n "yes"
+    fi
+'''
+
+GET_EC2_LOCAL_IP_SCRIPT = '''
+    echo -n $(ec2metadata --local-ipv4)
+'''
+
+# kill a process with a given name
+def bash_kill_process(pname):
+    return run_process(['bash', '-c', 
+        BASH_KILL_PROCESS_SCRIPT.format(**{'pname': pname})])
+
+# start an exectuable in the background, sending output to a file
+# stored at root with its name
+def start_exe(exe_path):
+    return run_process(['bash', '-c',
+        'nohup {} > ~/{}_output.log 2>&1 < /dev/null &'.format(exe_path, os.path.basename(exe_path))])
+
+def get_sim_install_path():
+    sim_path = os.environ.get('AVRS_INSTALL_PATH', 
+        os.path.join(os.environ['HOME'], 'autoverse-linux'))
+    return sim_path
+
+def get_rmw_qos_path():
+    return os.path.join(os.environ['HOME'], '.rmw_qos.xml')
+
+def reset_rmw_qos():
+    with open(get_rmw_qos_path(), 'w', encoding='utf-8') as f:
+        f.write(DEFAULT_RMW_QOS)
+
+def disable_peer_qos(peer_id):
+    if not os.path.isfile(get_rmw_qos_path()):
+        reset_rmw_qos()
+    pargs = {
+        'qos_path': get_rmw_qos_path(),
+        'peer_id': peer_id
+    }
+    return run_process(['bash', '-c',
+        DISABLE_PEER_QOS_SCRIPT.format(**pargs)])
+
+def enable_peer_qos(peer_id, peer_ip):
+    disable_peer_qos(peer_ip) # disable first
+    pargs = {
+        'qos_path': get_rmw_qos_path(),
+        'peer_id': peer_id,
+        'peer_ip': peer_ip
+    }
+    return run_process(['bash', '-c',
+        ENABLE_PEER_QOS_SCRIPT.format(**pargs)])
+
+def check_vcan_exists(vcan_name):
+    pargs = {
+        'vcan_name': vcan_name
+    }
+    pres = run_process(['bash', '-c',
+        CHECK_VCAN_EXISTS_SCRIPT.format(**pargs)])
+    return pres.out == 'yes'
+
+def get_auto_vcan_name(peer_id, vcan_id):
+    return 'vcan{}_{}'.format(peer_id, vcan_id)
+
+def connect_peer_vcan(peer_id, peer_ip, vcan_id, vcan_name=''):
+    vcan_id = 0
+    pargs = {
+        'peer_id': peer_id,
+        'peer_ip': peer_ip,
+        'remote_port': 20000 + peer_id * 3 + vcan_id, # three ports per peer_id
+        'local_port': 20000 + peer_id * 3 + vcan_id,
+        'vcan_name': vcan_name if vcan_name != '' else get_auto_vcan_name(peer_id, vcan_id)
+    }
+    return run_process(['bash', '-c',
+        CONNECT_PEER_VCAN_SCRIPT.format(**pargs)])
+
+def get_local_instance_ip():
+    try:
+        pres = run_process(['bash', '-c', GET_EC2_LOCAL_IP_SCRIPT])
+        return pres.out
+    except:
+        return '127.0.0.1'
+
+def reset_race_cloud_connection():
+    reset_rmw_qos()
+    run_process(['bash', '-c', 'rm ~/.simslot*']) # remove slot reservations
+    run_process(['bash', '-c', 'rm ~/.vcan*']) # remove lock files
+    bash_kill_process('cannelloni')
+
+def try_get_open_slot(team_name, ip):
+
+    slot_file_dir = os.environ['HOME']
+    for i in range(6):
+        slot_file_path = os.path.join(slot_file_dir, '.simslot_{}'.format(i))
+
+        if os.path.isfile(slot_file_path):
+            with open(slot_file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                if content == ip:
+                    return (True, 'slot {} is already reserved by you'.format(i), i)
+        else:
+            with open(slot_file_path, 'w', encoding='utf-8') as f:
+                f.write(ip)
+                return (True, 'reserved slot {}'.format(i), i)
+    return (False, 'no open slots', i)
+
+
+def call_race_cloud_api(body):
+    api_url = 'gitzels0l7.execute-api.us-east-1.amazonaws.com'
+
+    connection = http.client.HTTPSConnection(api_url)
+    headers = {
+        'Content-type': 'application/json',
+        'x-api-key': '7aQ83sJ89Q2DZ8NdIi9aUTBuUS2uyix5QoDwrl1j'
+    }
+    body = json.dumps(body).encode('utf-8')
+    connection.request('POST', '/beta/connect', body, headers)
+    response = connection.getresponse()
+    if response.status != 200:
+        return (False, 'response had status code {}'.format(response))
+    return (True, response.read().decode('utf-8'))
+
+def get_api_script_response(raw):
+    decoded = json.loads(raw)['body']
+    if decoded['script_response']['statusCode'] != 200:
+        return (False, 'inner response had bad status code {}'.format(decoded))
+    #print(decoded)
+    return (True, json.loads(decoded['script_response']['body']), decoded['sim_private_ip'])

autoverse_cli-0.12.1/src/avrs/requests/dump_sim_config.py

@@ -0,0 +1,14 @@
+from avrs.requests.request import AvrsApiRequest
+
+class AvrsDumpSimConfigRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'DumpSimConfig', '')
+        psr = parser.add_parser(
+            'dump-sim-config', 
+            help='dump all currently loaded configuration from the simulation')
+        
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        return {
+        }

{autoverse_cli-0.11.0 → autoverse_cli-0.12.1}/src/avrs/requests/request.py

@@ -12,6 +12,7 @@ class AvrsApiRequest:
         self.target_object_id = target_id
         self.request_type = request_type
         self.verbose = False
+        self.cfg = cfg
 
     def get_request(self, args):
         body = self.get_request_body(args)
@@ -38,7 +39,11 @@ class AvrsApiRequest:
         # print('{}'.format(response))
 
     def send_http_request(self, args):
-        connection = http.client.HTTPConnection("localhost", 30313, timeout=10)
+        sim_address = 'localhost'
+        if 'sim_address' in self.cfg:
+            sim_address = self.cfg['sim_address']
+        connection_addr = os.environ.get('AVRS_SIM_ADDRESS', 'localhost')
+        connection = http.client.HTTPConnection(connection_addr, 30313, timeout=10)
         headers = {'Content-type': 'application/json'}
         body = json.dumps(self.get_request(args)).encode('utf-8')
         connection.request('POST', '/post', body, headers)

{autoverse_cli-0.11.0 → autoverse_cli-0.12.1}/src/avrs/simconfig_util.py

@@ -11,13 +11,13 @@ class SimConfigFiles():
         }
         self.files = {}
 
-        ok, status = self.valdiate()
+        ok, status = self.validate()
         if ok:
             for name, path in self.required_files.items():
                 with open(path, 'r', encoding='utf-8') as f:
                     self.files[name] = json.load(f)
 
-    def valdiate(self):
+    def validate(self):
         for name, path in self.required_files.items():
             if not os.path.exists(path):
                 return (False, '{} not found'.format(path))
@@ -32,11 +32,11 @@ def compare_simconfig_defaults(sim_saved_dir, new_defaults_dir):
     old_cfg_files = SimConfigFiles(sim_saved_dir)
     new_cfg_files = SimConfigFiles(new_defaults_dir)
 
-    ok, status = old_cfg_files.valdiate()
+    ok, status = old_cfg_files.validate()
     if not ok:
         print(status)
         return
-    ok, status = new_cfg_files.valdiate()
+    ok, status = new_cfg_files.validate()
     if not ok:
         print(status)
         return

autoverse_cli-0.12.1/src/avrs/util.py

@@ -0,0 +1,13 @@
+import subprocess
+
+class ProcessResult():
+	def __init__(self, pres):
+		self.out = pres.stdout.decode('utf-8')
+		self.err = pres.stderr.decode('utf-8')
+
+def run_process(args):
+	result = subprocess.run(
+	    args, 
+	    stdout=subprocess.PIPE, 
+	    stderr=subprocess.PIPE)
+	return ProcessResult(result)

autoverse_cli-0.11.0/src/avrs/requests/reserve_mv_slot.py

@@ -1,112 +0,0 @@
-from avrs.requests.request import AvrsApiRequest
-from argparse import RawTextHelpFormatter
-
-RESERVE_MV_SLOT_HELP = '''
-slot (if an open slot exists, there are 4 total) using the given name to add a new vehicle and the appropriate topics.
-It will despawn the default vehicle and remove the default ROS topics when it is first run. Each vehicle added will be 
-given its own topics prefixed by the given name, and the slot index will correspond to the vcan it will use.
-Note that this will require having active vcans for each vehicle you wish to use. 
-(eg, if you want to use 4 vehicles, you will need vcan0, vcan1, vcan2, and vcan3)
-'''
-
-# use these to spawn MVs
-MV_LANDMARKS = [
-    'MvStart0',
-    'MvStart1',
-    'MvStart2',
-    'MvStart3'
-]
-
-class ReserveMvSlot(AvrsApiRequest):
-    def __init__(self, parser, cfg):
-        AvrsApiRequest.__init__(self, parser, cfg, 'SpawnObject', 0)
-        psr = parser.add_parser('reserve-mv-slot', help=RESERVE_MV_SLOT_HELP, formatter_class=RawTextHelpFormatter)
-
-        psr.add_argument(
-            'slot_name',
-            help='the name of the vehicle to put in the specified slot')
-
-        psr.add_argument(
-            'slot_index',
-            type=int,
-            choices=[0, 1, 2, 3],
-            help='the slot index (0-4) to reserve')
-
-        psr.add_argument(
-            '--bsu-can-name', 
-            default='vcan0',
-            help='the name of the CAN interface to use for the BSU CAN bus on the new vehicle')
-
-        psr.add_argument(
-            '--kistler-can-name',
-            default='vcan1',
-            help='the name of the CAN interface to use for the Kistler CAN bus on the new vehicle')
-
-        psr.add_argument(
-            '--badenia-can-name', 
-            default='vcan2',
-            help='the name of the CAN interface to use for the bandanania CAN bus on the new vehicle')
-
-        psr.add_argument(
-            '--with-view-cameras',
-            action='store_true',
-            help='if the new vehicle should have cameras attached to it')
-
-        psr.add_argument(
-            '--enable-lidar',
-            action='store_true',
-            help='if set, the lidar will be enabled on the new vehicle')
-
-        psr.add_argument(
-            '--enable-camera-sensor',
-            action='store_true',
-            help='if set, the camera will be enabled on the new vehicle')
-
-        psr.add_argument(
-            '--disable-hud',
-            action='store_true',
-            help='if set, the new vehicle will not create a HUD (mutiple HUDs will clutter the screen)')
-
-
-        psr.set_defaults(func=self.send_request)
-    
-    def get_request_body(self, args):
-
-        eav_init_pld = {
-            'TypeName': 'Eav24Initializer',
-            'Body': {
-                'bsuCanName': args.bsu_can_name,
-                'kistlerCanNam': args.kistler_can_name,
-                'badeniaCanName': args.badenia_can_name,
-                'bHudEnabled': not args.disable_hud,
-                'bEnableLidar': args.enable_lidar,
-                'bEnableCameraSensor': args.enable_camera_sensor
-            }
-        }
-
-        plds = [
-            eav_init_pld
-        ]
-
-        if args.with_view_cameras:
-            plds.append(
-                {
-                    'TypeName': 'InitializerTemplates',
-                    'Body': {
-                        'Templates': [
-                            {
-                                'PayloadType': 'SimViewTargetIpd',
-                                'PayloadSpec': 'DefaultCarCams'
-                            }
-                        ]
-                    }
-                })
-
-        return {
-            'Name': args.slot_name,
-            'Type': 'Eav24',
-            'Location': {},
-            'Rotation': {},
-            'Landmark': MV_LANDMARKS[args.slot_index],
-            'Payloads': plds
-        }