remotivelabs-cli 0.0.16__tar.gz → 0.0.17__tar.gz

{remotivelabs_cli-0.0.16 → remotivelabs_cli-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: remotivelabs-cli
-Version: 0.0.16
+Version: 0.0.17
 Summary: CLI for operating RemotiveCloud and RemotiveBroker
 Author: Johan Rask
 Author-email: johan.rask@remotivelabs.com

{remotivelabs_cli-0.0.16 → remotivelabs_cli-0.0.17}/cli/broker/brokers.py

@@ -11,7 +11,7 @@ from zeroconf import (
     Zeroconf,
 )
 
-from . import export, files, playback, record, scripting, signals
+from . import export, files, licenses, playback, record, scripting, signals
 
 app = typer.Typer(rich_markup_mode="rich")
 
@@ -85,7 +85,8 @@ app.add_typer(record.app, name="record", help="Record data on buses")
 app.add_typer(files.app, name="files", help="Upload/Download configurations and recordings")
 app.add_typer(signals.app, name="signals", help="Find and subscribe to signals")
 app.add_typer(export.app, name="export", help="Export to external formats")
-app.add_typer(scripting.app, name="scripting")
+app.add_typer(scripting.app, name="scripting", help="LUA scripting utilities")
+app.add_typer(licenses.app, name="license", help="View and request license to broker")
 
 if __name__ == "__main__":
     app()

{remotivelabs_cli-0.0.16 → remotivelabs_cli-0.0.17}/cli/broker/export.py

@@ -36,7 +36,7 @@ def influxdb(
     This is a sample for exporting and importing to InfluxDB using remotive-cli and influx-cli
 
     Export:
-    remotive broker export influxdb --url [URL] --output signals.influx --namespace VehicleBus  \\
+    remotive broker export influxdb --url [URL] --output signals.influx  \\
         --signal vehiclebus:Control.SteeringWheel_Position --signal Control.Accelerator_PedalPosition \\
         --signal vehiclebus:GpsPosition.GPS_Longitude --signal vehiclebus:GpsPosition.GPS_Latitude
 

{remotivelabs_cli-0.0.16 → remotivelabs_cli-0.0.17}/cli/broker/lib/broker.py

@@ -12,7 +12,7 @@ import typing
 import zipfile
 from dataclasses import dataclass
 from threading import Thread
-from typing import Callable, List, Sequence
+from typing import Callable, List, Sequence, Union
 
 import grpc
 import remotivelabs.broker.generated.sync.traffic_api_pb2 as traffic_api
@@ -33,8 +33,16 @@ class SubscribableSignal:
     namespace: str
 
 
+@dataclass
+class LicenseInfo:
+    valid: bool
+    expires: str
+    email: str
+    machine_id: str
+
+
 class Broker:
-    def __init__(self, url: str, api_key):
+    def __init__(self, url: str, api_key: Union[str, None] = None):
         self.url = url
         self.api_key = api_key
         self.q = queue.Queue()
@@ -531,3 +539,19 @@ class Broker:
             playbackConfig=playback_config,
             playbackMode=br.traffic_api_pb2.PlaybackMode(mode=item["mode"], offsetTime=get_offset_time()),
         )
+
+    def get_license(self) -> LicenseInfo:
+        license_info = self.system_stub.GetLicenseInfo(br.common_pb2.Empty())
+        return LicenseInfo(
+            valid=license_info.status == br.system_api_pb2.LicenseStatus.VALID,
+            expires=license_info.expires,
+            email=license_info.requestId,
+            machine_id=license_info.requestMachineId.decode("utf-8"),
+        )
+
+    def apply_license(self, license_data_b64: bytes):
+        license = br.system_api_pb2.License()
+        license.data = license_data_b64
+        license.termsAgreement = True
+        self.system_stub.SetLicense(license)
+        return self.get_license()

remotivelabs_cli-0.0.17/cli/broker/license_flows.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import json
+import time
+from typing import Union
+
+import grpc
+import requests
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+import cli.cloud.rest_helper as rest
+from cli.broker.lib.broker import Broker, LicenseInfo
+
+console = Console(stderr=True)
+
+
+class LicenseFlow:
+    def describe_with_url(self, url: str) -> LicenseInfo:
+        b = LicenseFlow.__try_connect_to_broker(
+            url=url,
+            progress_label=f"Fetching license from broker ({url})...",
+            on_error_progress_label=f"Fetching license from broker ({url})... make sure broker is running.",
+        )
+        return b.get_license()
+
+    def describe_with_hotspot(self, url: Union[str, None] = "http://192.168.4.1:50051"):
+        if url is None:
+            url = "http://192.168.4.1:50051"
+
+        b = LicenseFlow.__try_connect_to_broker(
+            url=url, progress_label=f"Fetching license from broker using hotspot ({url})... Make sure to switch to remotivelabs-xxx Wi-Fi"
+        )
+        return b.get_license()
+
+    def request_with_url_with_internet(self, url: str):
+        console.print("This requires internet connection from your computer during the entire licensing process")
+
+        email = LicenseFlow.__try_authenticate_and_get_email_from_cloud()
+
+        broker_to_license = LicenseFlow.__try_connect_to_broker(
+            url=url,
+            progress_label=f"Fetching existing broker license...({url})...",
+        )
+
+        existing_license = broker_to_license.get_license()
+        if existing_license.valid:
+            apply = typer.confirm(
+                f"This broker already has a valid license, and is licensed to {existing_license.email}. Do you still wish to proceed?"
+            )
+            if not apply:
+                return
+
+        console.print(
+            ":point_right: [bold yellow]This will request a new license or use an existing license if "
+            "this hardware has already been licensed[/bold yellow]"
+        )
+        apply_license = typer.confirm("Do you want to continue and agree to terms and conditions at https://remotivelabs.com/license?")
+        if not apply_license:
+            return
+
+        existing_license = broker_to_license.get_license()
+        license_data_b64 = LicenseFlow.__try_request_license(email, existing_license, "Requesting license...")
+
+        with use_progress("Applying license to broker..."):
+            new_license = broker_to_license.apply_license(license_data_b64)
+        if new_license.valid:
+            console.print(f":thumbsup: Successfully applied license, it remains valid until {new_license.expires}")
+
+    def request_with_hotspot(self, url: Union[str, None] = "http://192.168.4.1:50051"):
+        """
+        This flow expects changes between networks and tries to guide the user accordingly
+        :param url: If None it will use the default hotspot IP
+        """
+        if url is None:
+            url = "http://192.168.4.1:50051"
+
+        console.print(
+            "Licensing a broker over its wifi hotspot will require you to switch between internet connectivity "
+            "and remotivelabs-xxx wifi hotspot"
+        )
+
+        email = LicenseFlow.__try_authenticate_and_get_email_from_cloud()
+
+        broker_to_license = LicenseFlow.__try_connect_to_broker(
+            url=url,
+            progress_label=f"Fetching license from broker using hotspot ({url})... Make sure to switch to remotivelabs-xxx wifi",
+        )
+        existing_license = broker_to_license.get_license()
+        if existing_license.valid:
+            apply = typer.confirm(
+                f"This broker already has a valid license and is licensed to {existing_license.email}. Do you still wish to proceed?"
+            )
+            if not apply:
+                return
+
+        console.print(
+            ":point_right: [bold yellow]This will request a new license or use an existing license if "
+            "this hardware has already been licensed[/bold yellow]"
+        )
+        apply_license = typer.confirm("Do you want to continue and agree to terms and conditions at https://remotivelabs.com/license?")
+        if not apply_license:
+            return
+
+        license_data_b64 = LicenseFlow.__try_request_license(email, existing_license)
+
+        broker_to_license = LicenseFlow.__try_connect_to_broker(
+            url=url,
+            progress_label="Applying license to broker...  Make sure to switch back to remotivelabs-xxx wifi hotspot",
+        )
+        new_license = broker_to_license.apply_license(license_data_b64)
+        console.print(f":thumbsup: Successfully applied license, expires {new_license.expires}")
+
+    @staticmethod
+    def __try_connect_to_broker(url: str, progress_label: str, on_error_progress_label: Union[str, None] = None) -> Broker:
+        with use_progress(progress_label) as p:
+            while True:
+                try:
+                    broker_to_license = Broker(url=url)
+                    break
+                except grpc.RpcError:
+                    if on_error_progress_label is not None:
+                        p.update(
+                            p.task_ids[0],
+                            description=on_error_progress_label,
+                        )
+                    time.sleep(1)
+        if on_error_progress_label is None:
+            console.print(f":white_check_mark: {progress_label}")
+        else:
+            console.print(f":white_check_mark: {on_error_progress_label}")
+        return broker_to_license
+
+    @staticmethod
+    def __try_authenticate_and_get_email_from_cloud() -> str:
+        with use_progress("Fetching user info from cloud... Make sure you are connected to internet"):
+            while True:
+                try:
+                    r = rest.handle_get("/api/whoami", return_response=True, use_progress_indicator=False, timeout=5)
+                    break
+                except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+                    time.sleep(1)
+        console.print(":white_check_mark: Fetching user info from cloud... Make sure you are connected to internet")
+        return r.json()["email"]
+
+    @staticmethod
+    def __try_request_license(
+        email: str,
+        existing_license: LicenseInfo,
+        progress_label: str = "Requesting license... make sure to switch back to network with internet access",
+    ) -> bytes:
+        with use_progress(progress_label):
+            while True:
+                try:
+                    license_data_b64 = rest.request_license(email, json.loads(existing_license.machine_id)).encode()
+                    break
+                except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+                    time.sleep(1)
+        console.print(f":white_check_mark: {progress_label}")
+        return license_data_b64
+
+
+def use_progress(label: str):
+    p = Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True, expand=False)
+    p.add_task(label, total=1)
+    return p

remotivelabs_cli-0.0.17/cli/broker/licenses.py

@@ -0,0 +1,97 @@
+import dataclasses
+import json
+from enum import Enum
+
+import typer
+from rich import print_json
+
+from .license_flows import LicenseFlow
+
+app = typer.Typer()
+
+help_text = """
+    More info on our docs page
+    https://docs.remotivelabs.com/docs/remotive-broker/getting-started
+
+    --connect describes how the connection is made to the broker and helps us properly connect to broker
+
+      url      = Connects to the broker with the specified url, this is
+      hotspot  = If you are using RemotiveBox (our reference hardware) you can connect to the
+                 broker over its wifi hotspot. Getting the license from a RemotiveBox over its wifi hotspot
+                 requires you switch wi-fi network to the RemotiveBox hotspot called 'remotivelabs-xxx' where
+                 'xxx' is a random generated id.
+
+    --url is the broker url, this is mandatory when connect type is "url"
+    """
+
+
+class Connection(str, Enum):
+    hotspot = "hotspot"
+    url = "url"
+    # TODO - Support discover using mdns
+
+
+@app.command()
+def describe(
+    connect: Connection = typer.Option("url", case_sensitive=False, help="How to connect to broker"),
+    url: str = typer.Option("http://localhost:50051", is_eager=False, help="Broker URL", envvar="REMOTIVE_BROKER_URL"),
+):
+    """
+    Show licence information
+
+    More info on our docs page
+    https://docs.remotivelabs.com/docs/remotive-broker/getting-started
+
+    --connect describes how the connection is made to the broker and helps us properly connect to broker
+
+    url      = Connects to the broker with the specified url, this is
+    hotspot  = If you are using RemotiveBox (our reference hardware) you can connect to the
+               broker over its wifi hotspot. Getting the license from a RemotiveBox over its wifi hotspot
+               requires you switch wi-fi network to the RemotiveBox hotspot called 'remotivelabs-xxx' where
+               'xxx' is a random generated id.
+
+    --url is the broker url, this is mandatory when connect type is "url"
+    """
+    license_flow = LicenseFlow()
+    if connect == Connection.url:
+        existing_license = license_flow.describe_with_url(url)
+        print_json(json.dumps(dataclasses.asdict(existing_license)))
+    if connect == Connection.hotspot:
+        existing_license = license_flow.describe_with_hotspot(url if url != "http://localhost:50051" else None)
+        print_json(json.dumps(dataclasses.asdict(existing_license)))
+
+
+@app.command()
+def request(
+    connect: Connection = typer.Option("url", case_sensitive=False, help="How to connect to broker"),
+    url: str = typer.Option(
+        "http://localhost:50051",
+        is_eager=False,
+        help="Broker url, this is mandatory when connect type is 'url'",
+        envvar="REMOTIVE_BROKER_URL",
+    ),
+):
+    """
+    Requests and applies a new or existing License to a broker, Note that internet access is required on your
+    computer
+
+    More info on our docs page
+    https://docs.remotivelabs.com/docs/remotive-broker/getting-started
+
+    --connect describes how the connection is made to the broker and helps us properly connect to broker
+
+    url      = Use url to connect to broker (use --url)
+    hotspot  = If you are using RemotiveBox (our reference hardware) you can connect to the
+               broker over its wifi hotspot. Licensing a broker on a RemotiveBox over its wifi hotspot
+               requires you switch wi-fi network to the RemotiveBox hotspot called 'remotivelabs-xxx' where
+               'xxx' is a random generated id.
+               https://docs.remotivelabs.com/docs/remotive-broker/getting-started/remotive-box
+
+    --url is the broker url, this is mandatory when connect type is "url"
+    """
+
+    license_flow = LicenseFlow()
+    if connect == Connection.url:
+        license_flow.request_with_url_with_internet(url)
+    if connect == Connection.hotspot:
+        license_flow.request_with_hotspot(url if url != "http://localhost:50051" else None)

{remotivelabs_cli-0.0.16 → remotivelabs_cli-0.0.17}/cli/broker/signals.py

@@ -95,7 +95,8 @@ def subscribe(  # noqa: C901
 
     if script is not None:
         if len(signal) > 0:
-            ErrorPrinter.print_generic_error("You must must not specify namespace or signal when using --script")
+            ErrorPrinter.print_generic_error("You must must not specify --signal when using --script")
+            exit(1)
 
     plt.title("Signals")
 

{remotivelabs_cli-0.0.16 → remotivelabs_cli-0.0.17}/cli/cloud/recordings.py

@@ -459,8 +459,7 @@ def _do_change_playback_mode(mode: str, recording_session: str, broker: str, pro
             if json_context["recordingSessionId"] != recording_session:
                 ErrorPrinter.print_generic_error(
                     f"The recording id mounted is '{json_context['recordingSessionId']}' "
-                    f"which  not the same as you are trying to {mode}, "
-                    "use cmd below to mount this recording"
+                    f"which not the same as you are trying to {mode}, use cmd below to mount this recording"
                 )
                 ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
                 exit(1)

{remotivelabs_cli-0.0.16 → remotivelabs_cli-0.0.17}/cli/cloud/recordings_playback.py

@@ -3,16 +3,18 @@ from __future__ import annotations
 import datetime
 import json
 import tempfile
-from typing import List
+from pathlib import Path
+from typing import List, Union
 
 import grpc
 import rich
 import typer
+from rich import print as rich_rprint
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from cli.errors import ErrorPrinter
 
-from ..broker.lib.broker import Broker
+from ..broker.lib.broker import Broker, SubscribableSignal
 from . import rest_helper as rest
 
 app = typer.Typer(
@@ -89,6 +91,72 @@ def stop(
     _do_change_playback_mode("stop", recording_session, broker, project)
 
 
+# Copied from signals.py
+def read_scripted_code_file(file_path: Path) -> bytes:
+    # typer checks that the Path exists
+    with open(file_path, "rb") as file:
+        return file.read()
+
+
+@app.command()
+def subscribe(
+    recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
+    broker: str = typer.Option(None, help="Broker to use"),
+    signal: List[str] = typer.Option(None, help="Signal names to subscribe to, mandatory when not using script"),
+    script: Path = typer.Option(
+        None,
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        writable=False,
+        readable=True,
+        resolve_path=True,
+        help="Supply a path to Lua script that to use for signal transformation",
+    ),
+    on_change_only: bool = typer.Option(default=False, help="Only get signal if value is changed"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+):
+    """
+    Allows you to subscribe to signals based on a mounted recording without knowing the broker URL.
+    This simplifies when playing recordings from the cloud.
+
+    Terminal plotting is not yet supported here so we refer to remotive broker signals subscribe --x-plot for this.
+    """
+    if script is None:
+        if len(signal) == 0:
+            ErrorPrinter.print_generic_error("You must use include at least one signal and one namespace or use script when subscribing")
+            exit(1)
+    if script is not None:
+        if len(signal) > 0:
+            ErrorPrinter.print_generic_error("You must must not specify --signal when using --script")
+            exit(1)
+
+    broker_client = _get_broker_info(project, recording_session, broker, "subscribe")
+
+    try:
+        if script is not None:
+            script_src = read_scripted_code_file(script)
+            broker_client.subscribe_on_script(script_src, lambda sig: rich_rprint(json.dumps(list(sig))), on_change_only)
+        else:
+
+            def to_subscribable_signal(sig: str):
+                arr = sig.split(":")
+                if len(arr) != 2:
+                    ErrorPrinter.print_hint(f"--signal must have format namespace:signal ({sig})")
+                    exit(1)
+                return SubscribableSignal(namespace=arr[0], name=arr[1])
+
+            signals_to_subscribe_to = list(map(to_subscribable_signal, signal))
+            broker_client.long_name_subscribe(signals_to_subscribe_to, lambda sig: rich_rprint(json.dumps(list(sig))), on_change_only)
+            print("Subscribing to signals, press Ctrl+C to exit")
+    except grpc.RpcError as rpc_error:
+        ErrorPrinter.print_grpc_error(rpc_error)
+
+    except Exception as e:
+        ErrorPrinter.print_generic_error(e)
+        exit(1)
+
+
 def _do_change_playback_mode(
     mode: str,
     recording_session: str,
@@ -103,10 +171,8 @@ def _do_change_playback_mode(
     recordings: list = r["recordings"]
     files = list(map(lambda rec: {"recording": rec["fileName"], "namespace": rec["metadata"]["namespace"]}, recordings))
 
-    if broker is not None:
-        response = rest.handle_get(f"/api/project/{project}/brokers/{broker}", return_response=True, allow_status_codes=[404])
-    else:
-        response = rest.handle_get(f"/api/project/{project}/brokers/personal", return_response=True, allow_status_codes=[404])
+    broker_name = broker if broker is not None else "personal"
+    response = rest.handle_get(f"/api/project/{project}/brokers/{broker_name}", return_response=True, allow_status_codes=[404])
     if response.status_code == 404:
         broker_arg = ""
         if broker is not None:
@@ -164,8 +230,7 @@ def _verify_recording_on_broker(broker: Broker, recording_session: str, mode: st
             if json_context["recordingSessionId"] != recording_session:
                 ErrorPrinter.print_generic_error(
                     f"The recording id mounted is '{json_context['recordingSessionId']}' "
-                    f"which  not the same as you are trying to {mode}, "
-                    "use cmd below to mount this recording"
+                    f"which not the same as you are trying to {mode}, use cmd below to mount this recording"
                 )
                 ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
                 exit(1)
@@ -176,3 +241,22 @@ def _verify_recording_on_broker(broker: Broker, recording_session: str, mode: st
         else:
             ErrorPrinter.print_grpc_error(rpc_error)
         exit(1)
+
+
+def _get_broker_info(project: str, recording_session: str, broker: Union[str, None], mode: str) -> Broker:
+    # Verify it exists
+    rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
+
+    broker_name = broker if broker is not None else "personal"
+    response = rest.handle_get(f"/api/project/{project}/brokers/{broker_name}", return_response=True, allow_status_codes=[404])
+    if response.status_code == 404:
+        broker_arg = ""
+        if broker is not None:
+            broker_arg = f"--broker {broker} --ensure-broker-started"
+        ErrorPrinter.print_generic_error("You need to mount the recording before you play")
+        ErrorPrinter.print_hint(f"remotive cloud recordings mount {recording_session} {broker_arg} --project {project}")
+        exit(1)
+    broker_info = json.loads(response.text)
+    broker_client = Broker(broker_info["url"], None)
+    _verify_recording_on_broker(broker_client, recording_session, mode, project)
+    return broker_client

{remotivelabs_cli-0.0.16 → remotivelabs_cli-0.0.17}/cli/cloud/rest_helper.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
+import base64
 import json
 import logging
 import os
 import shutil
 from importlib.metadata import version
 from pathlib import Path
-from typing import List, Union
+from typing import Dict, List, Union
 
 import requests
 from rich.console import Console
@@ -23,11 +24,16 @@ if "REMOTIVE_CLOUD_HTTP_LOGGING" in os.environ:
     requests_log.setLevel(logging.DEBUG)
     requests_log.propagate = True
 global baseurl
+global license_server_base_url
 base_url = "https://cloud.remotivelabs.com"
+license_server_base_url = "https://license.cloud.remotivelabs.com"
 
 if "REMOTIVE_CLOUD_BASE_URL" in os.environ:
     base_url = os.environ["REMOTIVE_CLOUD_BASE_URL"]
 
+if "cloud-dev" in base_url:
+    license_server_base_url = "https://license.cloud-dev.remotivelabs.com"
+
 # if 'REMOTIVE_CLOUD_AUTH_TOKEN' not in os.environ:
 #    print('export REMOTIVE_CLOUD_AUTH_TOKEN=auth must be set')
 #    exit(0)
@@ -65,12 +71,23 @@ def ensure_auth_token():
     headers["User-Agent"] = f"remotivelabs-cli {cli_version}"
 
 
-def handle_get(url, params=None, return_response: bool = False, allow_status_codes=None, progress_label="Fetching..."):
+def handle_get(
+    url,
+    params=None,
+    return_response: bool = False,
+    allow_status_codes=None,
+    progress_label="Fetching...",
+    use_progress_indicator: bool = True,
+    timeout: int = 20,
+):
     if params is None:
         params = {}
     ensure_auth_token()
-    with use_progress(progress_label):
-        r = requests.get(f"{base_url}{url}", headers=headers, params=params)
+    if use_progress_indicator:
+        with use_progress(progress_label):
+            r = requests.get(f"{base_url}{url}", headers=headers, params=params, timeout=timeout)
+    else:
+        r = requests.get(f"{base_url}{url}", headers=headers, params=params, timeout=timeout)
 
     if return_response:
         check_api_result(r, allow_status_codes)
@@ -192,3 +209,18 @@ def download_file(save_file_name: str, url: str):
                 shutil.copyfileobj(stream_with_progress, out_file)
     else:
         check_api_result(download_resp)
+
+
+def request_license(email: str, machine_id: Dict[str, any]) -> str:
+    # Lets keep the email here so we have the same interface for both authenticated
+    # and not authenticated license requests.
+    # email will be validated in the license server to make sure it matches with the user of the
+    # access token so not any email is sent here
+    ensure_auth_token()
+    payload = {"id": email, "machine_id": machine_id}
+    b64_encoded_bytes = base64.encodebytes(json.dumps(payload).encode())
+    license_jsonb64 = {"licensejsonb64": b64_encoded_bytes.decode("utf-8")}
+    headers["content-type"] = "application/json"
+    r = requests.post(url=f"{license_server_base_url}/api/license/request", headers=headers, data=json.dumps(license_jsonb64))
+    check_api_result(r)
+    return r.json()["license_data"]

{remotivelabs_cli-0.0.16 → remotivelabs_cli-0.0.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "remotivelabs-cli"
-version = "0.0.16"
+version = "0.0.17"
 description = "CLI for operating RemotiveCloud and RemotiveBroker"
 authors = ["Johan Rask <johan.rask@remotivelabs.com>"]
 readme = "README.md"