outerbounds 0.3.52rc6__py3-none-any.whl → 0.3.53rc1__py3-none-any.whl

outerbounds/command_groups/cli.py

@@ -1,10 +1,12 @@
 import click
 from . import local_setup_cli
 from . import workstations_cli
+from . import perimeters_cli
 
 
 @click.command(
-    cls=click.CommandCollection, sources=[local_setup_cli.cli, workstations_cli.cli]
+    cls=click.CommandCollection,
+    sources=[local_setup_cli.cli, workstations_cli.cli, perimeters_cli.cli],
 )
 def cli(**kwargs):
     pass

outerbounds/command_groups/local_setup_cli.py

@@ -189,7 +189,7 @@ def check_ob_extension(narrator: Narrator) -> CommandStatus:
         if d.is_dir() and not d.name.startswith("__")
     ]
     subdirs.sort()
-    if subdirs != ["config", "plugins", "toplevel"]:
+    if subdirs != ["config", "plugins", "profilers", "toplevel"]:
         check_status.update(
             status=OuterboundsCommandStatus.FAIL,
             reason=BAD_EXTENSION_MESSAGE,
@@ -586,6 +586,12 @@ class ConfigurationWriter:
         self.out_dir = out_dir
         self.profile = profile
 
+        ob_config_dir = path.expanduser(os.getenv("OBP_CONFIG_DIR", out_dir))
+        self.ob_config_path = path.join(
+            ob_config_dir,
+            "ob_config_{}.json".format(profile) if profile else "ob_config.json",
+        )
+
     def decode(self):
         self.decoded_config = deserialize(self.encoded_config)
 
@@ -648,6 +654,15 @@ class ConfigurationWriter:
         with open(config_path, "w") as fd:
             json.dump(self.existing, fd, indent=4)
 
+        # Every time a config is initialized, we should also reset the corresponding ob_config[_profile].json
+        remote_config = metaflowconfig.init_config(self.out_dir, self.profile)
+        with open(self.ob_config_path, "w") as fd:
+            ob_config_dict = {
+                "OB_CURRENT_PERIMETER": remote_config["OBP_PERIMETER"],
+                "OB_CURRENT_PERIMETER_URL": remote_config["OBP_PERIMETER_URL"],
+            }
+            json.dump(ob_config_dict, fd, indent=4)
+
     def confirm_overwrite_config(self, config_path):
         if os.path.exists(config_path):
             if not click.confirm(
@@ -778,337 +793,3 @@ def configure(
     except Exception as e:
         click.secho("Writing the configuration file '{}' failed.".format(writer.path()))
         click.secho("Error: {}".format(str(e)))
-
-
-@cli.command(help="Switch current perimeter")
-@click.option(
-    "-o",
-    "--output",
-    default="",
-    help="Show output in the specified format.",
-    type=click.Choice(["json", ""]),
-)
-@click.option("--id", default="", type=str, help="Perimeter name to switch to")
-@click.option(
-    "-f",
-    "--force",
-    is_flag=True,
-    help="Force change the existing perimeter",
-    default=False,
-)
-def switch_perimeter(output="", id=None, force=False):
-    switch_perimeter_response = OuterboundsCommandResponse()
-
-    switch_perimeter_step = CommandStatus(
-        "SwitchPerimeter",
-        OuterboundsCommandStatus.OK,
-        "Perimeter was successfully switched!",
-    )
-
-    metaflow_home_dir = path.expanduser(
-        os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
-    )
-
-    if not os.path.exists("{}/config_{}.json".format(metaflow_home_dir, id)):
-        click.secho(
-            "Perimeter {} does not exist or you don't have access to it".format(id),
-            fg="red",
-            err=True,
-        )
-        switch_perimeter_step.update(
-            status=OuterboundsCommandStatus.FAIL,
-            reason="Perimeter {} does not exist or you don't have access to it".format(
-                id
-            ),
-            mitigation="Please contact your admin or the Outerbounds team for assistance.",
-        )
-        switch_perimeter_response.add_step(switch_perimeter_step)
-        if output == "json":
-            click.echo(json.dumps(switch_perimeter_response.as_dict(), indent=4))
-        return
-
-    # If OBP_CONFIG_DIR is set, use that, otherwise use METAFLOW_HOME
-    # If neither are set, use ~/.metaflowconfig
-    obp_config_dir = path.expanduser(
-        os.environ.get(
-            "OBP_CONFIG_DIR", os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
-        )
-    )
-
-    path_to_config = os.path.expanduser(os.path.join(obp_config_dir, "ob_config.json"))
-
-    if not os.path.exists(path_to_config):
-        click.secho(
-            "Config file not found at {}".format(path_to_config), fg="red", err=True
-        )
-        switch_perimeter_step.update(
-            status=OuterboundsCommandStatus.FAIL,
-            reason="Config file not found",
-            mitigation="Please make sure the config file exists at {}".format(
-                path_to_config
-            ),
-        )
-        switch_perimeter_response.add_step(switch_perimeter_step)
-        if output == "json":
-            click.echo(json.dumps(switch_perimeter_response.as_dict(), indent=4))
-        return
-
-    import fcntl
-
-    fd = os.open(path_to_config, os.O_WRONLY)
-
-    try:
-        if not force:
-            # Try to acquire an exclusive lock
-            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-        else:
-            click.secho(
-                "Force flag is set. Perimeter will be switched, but can have unintended consequences on other running processes.",
-                fg="yellow",
-                err=True,
-            )
-
-        ob_config_dict = {"OB_CURRENT_PERIMETER": str(id)}
-
-        # Now that we have the lock, we can safely write to the file
-        with open(path_to_config, "w") as file:
-            json.dump(ob_config_dict, file, indent=4)
-
-        click.secho("Perimeter switched to {}".format(id), fg="green", err=True)
-    except BlockingIOError:
-        # This exception is raised if the file is already locked (non-blocking mode)
-        # Note that its the metaflow package (the extension actually) that acquires a shared read lock
-        # on the file whenever a process imports metaflow.
-        # In the future we might want to get smarter about it and show which process is holding the lock.
-        click.secho(
-            "Can't switch perimeter while Metaflow is in use. Please make sure there are no running python processes or notebooks using metaflow.",
-            fg="red",
-            err=True,
-        )
-        switch_perimeter_step.update(
-            status=OuterboundsCommandStatus.FAIL,
-            reason="Can't switch perimeter while Metaflow is in use.",
-            mitigation="Please make sure there are no running python processes or notebooks using metaflow.",
-        )
-
-    switch_perimeter_response.add_step(switch_perimeter_step)
-    if output == "json":
-        click.echo(json.dumps(switch_perimeter_response.as_dict(), indent=4))
-        return
-
-
-@cli.command(help="Show current perimeter")
-@click.option(
-    "-o",
-    "--output",
-    default="",
-    help="Show output in the specified format.",
-    type=click.Choice(["json", ""]),
-)
-def show_current_perimeter(output=""):
-    show_current_perimeter_response = OuterboundsCommandResponse()
-
-    show_current_perimeter_step = CommandStatus(
-        "ShowCurrentPerimeter",
-        OuterboundsCommandStatus.OK,
-        "Current Perimeter Fetch Successful.",
-    )
-
-    metaflow_home_dir = path.expanduser(
-        os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
-    )
-
-    # If OBP_CONFIG_DIR is set, use that, otherwise use METAFLOW_HOME
-    # If neither are set, use ~/.metaflowconfig
-    obp_config_dir = path.expanduser(
-        os.environ.get(
-            "OBP_CONFIG_DIR", os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
-        )
-    )
-
-    path_to_config = os.path.expanduser(os.path.join(obp_config_dir, "ob_config.json"))
-
-    if not os.path.exists(path_to_config):
-        click.secho(
-            "Config file not found at {}".format(path_to_config), fg="red", err=True
-        )
-        show_current_perimeter_step.update(
-            status=OuterboundsCommandStatus.FAIL,
-            reason="Config file not found",
-            mitigation="Please make sure the config file exists at {}".format(
-                path_to_config
-            ),
-        )
-        show_current_perimeter_response.add_step(show_current_perimeter_step)
-        if output == "json":
-            click.echo(json.dumps(show_current_perimeter_response.as_dict(), indent=4))
-        return
-
-    with open(path_to_config, "r") as file:
-        ob_config_dict = json.load(file)
-
-    if "OB_CURRENT_PERIMETER" not in ob_config_dict:
-        click.secho(
-            "OB_CURRENT_PERIMETER not found in Config file: {}".format(path_to_config),
-            fg="red",
-            err=True,
-        )
-        show_current_perimeter_step.update(
-            status=OuterboundsCommandStatus.FAIL,
-            reason="OB_CURRENT_PERIMETER not found in Config file: {}",
-            mitigation="",
-        )
-        show_current_perimeter_response.add_step(show_current_perimeter_step)
-        if output == "json":
-            click.echo(json.dumps(show_current_perimeter_response.as_dict(), indent=4))
-        return
-
-    if os.path.exists(
-        os.path.join(
-            metaflow_home_dir,
-            "config_{}.json".format(ob_config_dict["OB_CURRENT_PERIMETER"]),
-        )
-    ):
-        click.secho(
-            "Current Perimeter: {}".format(ob_config_dict["OB_CURRENT_PERIMETER"]),
-            fg="green",
-            err=True,
-        )
-        show_current_perimeter_response.add_or_update_data(
-            "current_perimeter", ob_config_dict["OB_CURRENT_PERIMETER"]
-        )
-    else:
-        click.secho(
-            "Perimeter config file not found at {}".format(
-                os.path.join(
-                    metaflow_home_dir,
-                    "config_{}.json".format(ob_config_dict["OB_CURRENT_PERIMETER"]),
-                )
-            ),
-            fg="red",
-            err=True,
-        )
-        show_current_perimeter_step.update(
-            status=OuterboundsCommandStatus.FAIL,
-            reason="Perimeter config file not found",
-            mitigation="Please make sure the perimeter config file exists at {}/config_{}.json".format(
-                metaflow_home_dir, ob_config_dict["OB_CURRENT_PERIMETER"]
-            ),
-        )
-        show_current_perimeter_response.add_step(show_current_perimeter_step)
-
-    if output == "json":
-        click.echo(json.dumps(show_current_perimeter_response.as_dict(), indent=4))
-
-
-@cli.command(help="List all available perimeters")
-@click.option(
-    "-o",
-    "--output",
-    default="",
-    help="Show output in the specified format.",
-    type=click.Choice(["json", ""]),
-)
-def list_perimeters(output=""):
-    list_perimeters_response = OuterboundsCommandResponse()
-
-    list_perimeters_step = CommandStatus(
-        "ListPerimeters", OuterboundsCommandStatus.OK, "Perimeter Fetch Successful."
-    )
-
-    metaflow_home_dir = path.expanduser(
-        os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
-    )
-
-    # If OBP_CONFIG_DIR is set, use that, otherwise use METAFLOW_HOME
-    # If neither are set, use ~/.metaflowconfig
-    obp_config_dir = path.expanduser(
-        os.environ.get(
-            "OBP_CONFIG_DIR", os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
-        )
-    )
-
-    path_to_config = os.path.expanduser(os.path.join(obp_config_dir, "ob_config.json"))
-
-    if not os.path.exists(path_to_config):
-        click.secho(
-            "Config file not found at {}".format(path_to_config), fg="red", err=True
-        )
-        list_perimeters_step.update(
-            status=OuterboundsCommandStatus.FAIL,
-            reason="Config file not found",
-            mitigation="Please make sure the config file exists at {}".format(
-                path_to_config
-            ),
-        )
-        list_perimeters_response.add_step(list_perimeters_step)
-        if output == "json":
-            click.echo(json.dumps(list_perimeters_response.as_dict(), indent=4))
-        return
-
-    with open(path_to_config, "r") as file:
-        ob_config_dict = json.load(file)
-
-    if "OB_CURRENT_PERIMETER" not in ob_config_dict:
-        click.secho(
-            "OB_CURRENT_PERIMETER not found in Config file: {}".format(path_to_config),
-            fg="red",
-            err=True,
-        )
-        list_perimeters_step.update(
-            status=OuterboundsCommandStatus.FAIL,
-            reason="OB_CURRENT_PERIMETER not found in Config file: {}",
-            mitigation="",
-        )
-        list_perimeters_response.add_step(list_perimeters_step)
-        if output == "json":
-            click.echo(json.dumps(list_perimeters_response.as_dict(), indent=4))
-        return
-
-    if os.path.exists(
-        os.path.join(
-            metaflow_home_dir,
-            "config_{}.json".format(ob_config_dict["OB_CURRENT_PERIMETER"]),
-        )
-    ):
-        active_perimeter = ob_config_dict["OB_CURRENT_PERIMETER"]
-    else:
-        click.secho(
-            "Perimeter config file not found at {}".format(
-                os.path.join(
-                    metaflow_home_dir,
-                    "config_{}.json".format(ob_config_dict["OB_CURRENT_PERIMETER"]),
-                )
-            ),
-            fg="red",
-            err=True,
-        )
-        list_perimeters_step.update(
-            status=OuterboundsCommandStatus.FAIL,
-            reason="Perimeter config file not found",
-            mitigation="Please make sure the perimeter config file exists at {}/config_{}.json".format(
-                metaflow_home_dir, ob_config_dict["OB_CURRENT_PERIMETER"]
-            ),
-        )
-        list_perimeters_response.add_step(list_perimeters_step)
-        if output == "json":
-            click.echo(json.dumps(list_perimeters_response.as_dict(), indent=4))
-        return
-
-    click.secho("Perimeter: {} (active)".format(active_perimeter), fg="green", err=True)
-
-    perimeter_list = []
-    for file in os.listdir(metaflow_home_dir):
-        if file.startswith("config_") and file.endswith(".json"):
-            perimeter_id = file.split("_")[1].split(".")[0]
-            perimeter_list.append(
-                {"id": perimeter_id, "active": perimeter_id == active_perimeter}
-            )
-
-            if perimeter_id != active_perimeter:
-                click.secho("Perimeter: {}".format(perimeter_id), err=True)
-
-    list_perimeters_response.add_or_update_data("perimeters", perimeter_list)
-
-    if output == "json":
-        click.echo(json.dumps(list_perimeters_response.as_dict(), indent=4))

outerbounds/command_groups/perimeters_cli.py

@@ -0,0 +1,374 @@
+import base64
+import hashlib
+import json
+import os
+import re
+import subprocess
+import sys
+import zlib
+from base64 import b64decode, b64encode
+from importlib.machinery import PathFinder
+from os import path
+from pathlib import Path
+from typing import Any, Callable, Dict, List
+
+import boto3
+import click
+import requests
+from requests.exceptions import HTTPError
+
+from ..utils import kubeconfig, metaflowconfig
+from ..utils.schema import (
+    CommandStatus,
+    OuterboundsCommandResponse,
+    OuterboundsCommandStatus,
+)
+
+
+@click.group()
+def cli(**kwargs):
+    pass
+
+
+@cli.command(help="Switch current perimeter", hidden=True)
+@click.option(
+    "-d",
+    "--config-dir",
+    default=path.expanduser(os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")),
+    help="Path to Metaflow configuration directory",
+    show_default=True,
+)
+@click.option(
+    "-p",
+    "--profile",
+    default=os.environ.get("METAFLOW_PROFILE", ""),
+    help="The named metaflow profile in which your workstation exists",
+)
+@click.option(
+    "-o",
+    "--output",
+    default="",
+    help="Show output in the specified format.",
+    type=click.Choice(["json", ""]),
+)
+@click.option("--id", default="", type=str, help="Perimeter name to switch to")
+@click.option(
+    "-f",
+    "--force",
+    is_flag=True,
+    help="Force change the existing perimeter",
+    default=False,
+)
+def switch_perimeter(config_dir=None, profile=None, output="", id=None, force=False):
+    switch_perimeter_response = OuterboundsCommandResponse()
+
+    switch_perimeter_step = CommandStatus(
+        "SwitchPerimeter",
+        OuterboundsCommandStatus.OK,
+        "Perimeter was successfully switched!",
+    )
+
+    perimeters = get_perimeters_from_api_or_fail_command(
+        config_dir, profile, output, switch_perimeter_response, switch_perimeter_step
+    )
+    confirm_user_has_access_to_perimeter_or_fail(
+        id, perimeters, output, switch_perimeter_response, switch_perimeter_step
+    )
+
+    path_to_config = get_ob_config_file_path(config_dir, profile)
+
+    import fcntl
+
+    try:
+        if os.path.exists(path_to_config):
+            if not force:
+                fd = os.open(path_to_config, os.O_WRONLY)
+                # Try to acquire an exclusive lock
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            else:
+                click.secho(
+                    "Force flag is set. Perimeter will be switched, but can have unintended consequences on other running processes.",
+                    fg="yellow",
+                    err=True,
+                )
+
+        ob_config_dict = {
+            "OB_CURRENT_PERIMETER": str(id),
+            "OB_CURRENT_PERIMETER_URL": perimeters[id]["remote_config_url"],
+        }
+
+        # Now that we have the lock, we can safely write to the file
+        with open(path_to_config, "w") as file:
+            json.dump(ob_config_dict, file, indent=4)
+
+        click.secho("Perimeter switched to {}".format(id), fg="green", err=True)
+    except BlockingIOError:
+        # This exception is raised if the file is already locked (non-blocking mode)
+        # Note that its the metaflow package (the extension actually) that acquires a shared read lock
+        # on the file whenever a process imports metaflow.
+        # In the future we might want to get smarter about it and show which process is holding the lock.
+        click.secho(
+            "Can't switch perimeter while Metaflow is in use. Please make sure there are no running python processes or notebooks using metaflow.",
+            fg="red",
+            err=True,
+        )
+        switch_perimeter_step.update(
+            status=OuterboundsCommandStatus.FAIL,
+            reason="Can't switch perimeter while Metaflow is in use.",
+            mitigation="Please make sure there are no running python processes or notebooks using metaflow.",
+        )
+
+    switch_perimeter_response.add_step(switch_perimeter_step)
+    if output == "json":
+        click.echo(json.dumps(switch_perimeter_response.as_dict(), indent=4))
+        return
+
+
+@cli.command(help="Show current perimeter", hidden=True)
+@click.option(
+    "-d",
+    "--config-dir",
+    default=path.expanduser(os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")),
+    help="Path to Metaflow configuration directory",
+    show_default=True,
+)
+@click.option(
+    "-p",
+    "--profile",
+    default=os.environ.get("METAFLOW_PROFILE", ""),
+    help="Configure a named profile. Activate the profile by setting "
+    "`METAFLOW_PROFILE` environment variable.",
+)
+@click.option(
+    "-o",
+    "--output",
+    default="",
+    help="Show output in the specified format.",
+    type=click.Choice(["json", ""]),
+)
+def show_current_perimeter(config_dir=None, profile=None, output=""):
+    show_current_perimeter_response = OuterboundsCommandResponse()
+
+    show_current_perimeter_step = CommandStatus(
+        "ShowCurrentPerimeter",
+        OuterboundsCommandStatus.OK,
+        "Current Perimeter Fetch Successful.",
+    )
+
+    ob_config_dict = get_ob_config_or_fail_command(
+        config_dir,
+        profile,
+        output,
+        show_current_perimeter_response,
+        show_current_perimeter_step,
+    )
+
+    perimeters = get_perimeters_from_api_or_fail_command(
+        config_dir,
+        profile,
+        output,
+        show_current_perimeter_response,
+        show_current_perimeter_step,
+    )
+    confirm_user_has_access_to_perimeter_or_fail(
+        ob_config_dict["OB_CURRENT_PERIMETER"],
+        perimeters,
+        output,
+        show_current_perimeter_response,
+        show_current_perimeter_step,
+    )
+
+    click.secho(
+        "Current Perimeter: {}".format(ob_config_dict["OB_CURRENT_PERIMETER"]),
+        fg="green",
+        err=True,
+    )
+
+    show_current_perimeter_response.add_or_update_data(
+        "current_perimeter", ob_config_dict["OB_CURRENT_PERIMETER"]
+    )
+
+    if output == "json":
+        click.echo(json.dumps(show_current_perimeter_response.as_dict(), indent=4))
+
+
+@cli.command(help="List all available perimeters", hidden=True)
+@click.option(
+    "-d",
+    "--config-dir",
+    default=path.expanduser(os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")),
+    help="Path to Metaflow configuration directory",
+    show_default=True,
+)
+@click.option(
+    "-p",
+    "--profile",
+    default=os.environ.get("METAFLOW_PROFILE", ""),
+    help="The named metaflow profile in which your workstation exists",
+)
+@click.option(
+    "-o",
+    "--output",
+    default="",
+    help="Show output in the specified format.",
+    type=click.Choice(["json", ""]),
+)
+def list_perimeters(config_dir=None, profile=None, output=""):
+    list_perimeters_response = OuterboundsCommandResponse()
+
+    list_perimeters_step = CommandStatus(
+        "ListPerimeters", OuterboundsCommandStatus.OK, "Perimeter Fetch Successful."
+    )
+
+    ob_config_dict = get_ob_config_or_fail_command(
+        config_dir, profile, output, list_perimeters_response, list_perimeters_step
+    )
+    active_perimeter = ob_config_dict["OB_CURRENT_PERIMETER"]
+
+    perimeters = get_perimeters_from_api_or_fail_command(
+        config_dir, profile, output, list_perimeters_response, list_perimeters_step
+    )
+
+    perimeter_list = []
+    for perimeter in perimeters.values():
+        status = "OK"
+        perimeter_list.append(
+            {
+                "id": perimeter["perimeter"],
+                "active": perimeter["perimeter"] == active_perimeter,
+                "status": status,
+            }
+        )
+        if perimeter["perimeter"] != active_perimeter:
+            click.secho("Perimeter: {}".format(perimeter["perimeter"]), err=True)
+        else:
+            click.secho(
+                "Perimeter: {} (active)".format(perimeter["perimeter"]),
+                fg="green",
+                err=True,
+            )
+
+    list_perimeters_response.add_or_update_data("perimeters", perimeter_list)
+
+    if output == "json":
+        click.echo(json.dumps(list_perimeters_response.as_dict(), indent=4))
+
+
+def get_list_perimeters_api_response(config_dir, profile):
+    metaflow_token = metaflowconfig.get_metaflow_token_from_config(config_dir, profile)
+    api_url = metaflowconfig.get_sanitized_url_from_config(
+        config_dir, profile, "OBP_API_SERVER"
+    )
+    perimeters_response = requests.get(
+        f"{api_url}/v1/me/perimeters?privilege=Execute",
+        headers={"x-api-key": metaflow_token},
+    )
+    perimeters_response.raise_for_status()
+    return perimeters_response.json()["perimeters"]
+
+
+def get_ob_config_file_path(config_dir: str, profile: str) -> str:
+    # If OBP_CONFIG_DIR is set, use that, otherwise use METAFLOW_HOME
+    # If neither are set, use ~/.metaflowconfig
+    obp_config_dir = path.expanduser(os.environ.get("OBP_CONFIG_DIR", config_dir))
+
+    ob_config_filename = f"ob_config_{profile}.json" if profile else "ob_config.json"
+    return os.path.expanduser(os.path.join(obp_config_dir, ob_config_filename))
+
+
+def get_perimeters_from_api_or_fail_command(
+    config_dir: str,
+    profile: str,
+    output: str,
+    command_response: OuterboundsCommandResponse,
+    command_step: CommandStatus,
+) -> Dict[str, Dict[str, str]]:
+    try:
+        perimeters = get_list_perimeters_api_response(config_dir, profile)
+    except:
+        click.secho(
+            "Failed to fetch perimeters from API.",
+            fg="red",
+            err=True,
+        )
+        command_step.update(
+            status=OuterboundsCommandStatus.FAIL,
+            reason="Failed to fetch perimeters from API",
+            mitigation="",
+        )
+        command_response.add_step(command_step)
+        if output == "json":
+            click.echo(json.dumps(command_response.as_dict(), indent=4))
+        sys.exit(1)
+    return {p["perimeter"]: p for p in perimeters}
+
+
+def get_ob_config_or_fail_command(
+    config_dir: str,
+    profile: str,
+    output: str,
+    command_response: OuterboundsCommandResponse,
+    command_step: CommandStatus,
+) -> Dict[str, str]:
+    path_to_config = get_ob_config_file_path(config_dir, profile)
+
+    if not os.path.exists(path_to_config):
+        click.secho(
+            "Config file not found at {}".format(path_to_config), fg="red", err=True
+        )
+        command_step.update(
+            status=OuterboundsCommandStatus.FAIL,
+            reason="Config file not found",
+            mitigation="Please make sure the config file exists at {}".format(
+                path_to_config
+            ),
+        )
+        command_response.add_step(command_step)
+        if output == "json":
+            click.echo(json.dumps(command_response.as_dict(), indent=4))
+        sys.exit(1)
+
+    with open(path_to_config, "r") as file:
+        ob_config_dict = json.load(file)
+
+    if "OB_CURRENT_PERIMETER" not in ob_config_dict:
+        click.secho(
+            "OB_CURRENT_PERIMETER not found in Config file: {}".format(path_to_config),
+            fg="red",
+            err=True,
+        )
+        command_step.update(
+            status=OuterboundsCommandStatus.FAIL,
+            reason="OB_CURRENT_PERIMETER not found in Config file: {}",
+            mitigation="",
+        )
+        command_response.add_step(command_step)
+        if output == "json":
+            click.echo(json.dumps(command_response.as_dict(), indent=4))
+        sys.exit(1)
+
+    return ob_config_dict
+
+
+def confirm_user_has_access_to_perimeter_or_fail(
+    perimeter_id: str,
+    perimeters: Dict[str, Any],
+    output: str,
+    command_response: OuterboundsCommandResponse,
+    command_step: CommandStatus,
+):
+    if perimeter_id not in perimeters:
+        click.secho(
+            f"You do not have access to perimeter {perimeter_id} or it does not exist.",
+            fg="red",
+            err=True,
+        )
+        command_step.update(
+            status=OuterboundsCommandStatus.FAIL,
+            reason=f"You do not have access to perimeter {perimeter_id} or it does not exist.",
+            mitigation="",
+        )
+        command_response.add_step(command_step)
+        if output == "json":
+            click.echo(json.dumps(command_response.as_dict(), indent=4))
+        sys.exit(1)

outerbounds/utils/metaflowconfig.py

@@ -1,54 +1,41 @@
 import json
 import os
+import requests
 from os import path
+import requests
 
 
-def init_config():
-    # Read configuration from $METAFLOW_HOME/config_<profile>.json.
-    home = os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
-    profile = get_metaflow_profile()
-    path_to_config = os.path.join(home, "config.json")
-    if profile:
-        path_to_config = os.path.join(home, "config_%s.json" % profile)
-    path_to_config = os.path.expanduser(path_to_config)
-    config = {}
-    if os.path.exists(path_to_config):
-        with open(path_to_config, encoding="utf-8") as f:
-            return json.load(f)
-    elif profile:
-        raise Exception(
-            "Unable to locate METAFLOW_PROFILE '%s' in '%s')" % (profile, home)
-        )
-    return config
-
-
-def get_metaflow_profile():
-    # If OBP_CONFIG_DIR is set, use that, otherwise use METAFLOW_HOME
-    # If neither are set, use ~/.metaflowconfig
-    obp_config_dir = path.expanduser(
-        os.environ.get(
-            "OBP_CONFIG_DIR", os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
-        )
+def init_config(config_dir="", profile="") -> dict:
+    profile = profile or os.environ.get("METAFLOW_PROFILE")
+    config_dir = config_dir or os.path.expanduser(
+        os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
     )
 
-    file_path = os.path.join(obp_config_dir, "ob_config.json")
+    config_filename = f"config_{profile}.json" if profile else "config.json"
+    path_to_config = os.path.join(config_dir, config_filename)
+
+    if os.path.exists(path_to_config):
+        with open(path_to_config, encoding="utf-8") as json_file:
+            config = json.load(json_file)
+    else:
+        raise Exception("Unable to locate metaflow config at '%s')" % (path_to_config))
 
-    if os.path.exists(file_path):
-        with open(file_path, "r") as f:
-            ob_config = json.loads(f.read())
+    # This is new remote-metaflow config; fetch it from the URL
+    if "OBP_METAFLOW_CONFIG_URL" in config:
+        if config is None or "METAFLOW_SERVICE_AUTH_KEY" not in config:
+            raise Exception("METAFLOW_SERVICE_AUTH_KEY not found in config file")
 
-        if "OB_CURRENT_PERIMETER" in ob_config:
-            return ob_config["OB_CURRENT_PERIMETER"]
-        else:
-            raise Exception(f"OB_CURRENT_PERIMETER not found in {file_path}")
-    elif "OBP_CONFIG_DIR" in os.environ:
-        raise Exception(
-            "OBP_CONFIG_DIR is set, but no ob_config.json found in that directory"
+        config_response = requests.get(
+            config["OBP_METAFLOW_CONFIG_URL"],
+            headers={"x-api-key": f'{config["METAFLOW_SERVICE_AUTH_KEY"]}'},
         )
-    elif "METAFLOW_PROFILE" in os.environ:
-        return os.environ["METAFLOW_PROFILE"]
+        config_response.raise_for_status()
+        remote_config = config_response.json()["config"]
+        remote_config["METAFLOW_SERVICE_AUTH_KEY"] = config["METAFLOW_SERVICE_AUTH_KEY"]
+        return remote_config
 
-    return ""
+    # Legacy config, use from filesystem
+    return config
 
 
 def get_metaflow_token_from_config(config_dir: str, profile: str) -> str:
@@ -59,13 +46,10 @@ def get_metaflow_token_from_config(config_dir: str, profile: str) -> str:
         config_dir (str): Path to the config directory
         profile (str): The named metaflow profile
     """
-    config_filename = f"config_{profile}.json" if profile else "config.json"
-    config_path = os.path.join(config_dir, config_filename)
-    with open(config_path) as json_file:
-        config = json.load(json_file)
-        if config is None or "METAFLOW_SERVICE_AUTH_KEY" not in config:
-            raise Exception("METAFLOW_SERVICE_AUTH_KEY not found in config file")
-        return config["METAFLOW_SERVICE_AUTH_KEY"]
+    config = init_config(config_dir, profile)
+    if config is None or "METAFLOW_SERVICE_AUTH_KEY" not in config:
+        raise Exception("METAFLOW_SERVICE_AUTH_KEY not found in config file")
+    return config["METAFLOW_SERVICE_AUTH_KEY"]
 
 
 def get_sanitized_url_from_config(config_dir: str, profile: str, key: str) -> str:
@@ -77,16 +61,12 @@ def get_sanitized_url_from_config(config_dir: str, profile: str, key: str) -> st
         profile (str): The named metaflow profile
         key (str): The key to look up in the config file
     """
-    config_filename = f"config_{profile}.json" if profile else "config.json"
-    config_path = os.path.join(config_dir, config_filename)
-
-    with open(config_path) as json_file:
-        config = json.load(json_file)
-        if key not in config:
-            raise Exception(f"Key {key} not found in config file {config_path}")
-        url_in_config = config[key]
-        if not url_in_config.startswith("https://"):
-            url_in_config = f"https://{url_in_config}"
-
-        url_in_config = url_in_config.rstrip("/")
-        return url_in_config
+    config = init_config(config_dir, profile)
+    if key not in config:
+        raise Exception(f"Key {key} not found in config")
+    url_in_config = config[key]
+    if not url_in_config.startswith("https://"):
+        url_in_config = f"https://{url_in_config}"
+
+    url_in_config = url_in_config.rstrip("/")
+    return url_in_config

{outerbounds-0.3.52rc6.dist-info → outerbounds-0.3.53rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: outerbounds
-Version: 0.3.52rc6
+Version: 0.3.53rc1
 Summary: More Data Science, Less Administration
 License: Proprietary
 Keywords: data science,machine learning,MLOps
@@ -24,7 +24,7 @@ Requires-Dist: google-api-core (>=2.16.1,<3.0.0) ; extra == "gcp"
 Requires-Dist: google-auth (>=2.27.0,<3.0.0) ; extra == "gcp"
 Requires-Dist: google-cloud-storage (>=2.14.0,<3.0.0) ; extra == "gcp"
 Requires-Dist: ob-metaflow (==2.11.0.4)
-Requires-Dist: ob-metaflow-extensions (==1.1.42rc1)
+Requires-Dist: ob-metaflow-extensions (==1.1.43)
 Requires-Dist: opentelemetry-distro (==0.41b0)
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (==1.20.0)
 Requires-Dist: opentelemetry-instrumentation-requests (==0.41b0)

{outerbounds-0.3.52rc6.dist-info → outerbounds-0.3.53rc1.dist-info}/RECORD

@@ -1,14 +1,15 @@
 outerbounds/__init__.py,sha256=GPdaubvAYF8pOFWJ3b-sPMKCpyfpteWVMZWkmaYhxRw,32
 outerbounds/cli_main.py,sha256=e9UMnPysmc7gbrimq2I4KfltggyU7pw59Cn9aEguVcU,74
 outerbounds/command_groups/__init__.py,sha256=QPWtj5wDRTINDxVUL7XPqG3HoxHNvYOg08EnuSZB2Hc,21
-outerbounds/command_groups/cli.py,sha256=61VsBlPG2ykP_786eCyllqeM8DMhPAOfj2FhktrSd7k,207
-outerbounds/command_groups/local_setup_cli.py,sha256=7U4mZbAXBDsY-ghKAzcfgMkuwnTExDW0nyJ52nVCg-g,40694
+outerbounds/command_groups/cli.py,sha256=H4LxcYTmsY9DQUrReSRLjvbg9s9Ro7s-eUrcMqEJ_9A,261
+outerbounds/command_groups/local_setup_cli.py,sha256=DwQYfTnK_kb63oQM0A8cAJeLRCTLOcyEwjkBL42O1fQ,29414
+outerbounds/command_groups/perimeters_cli.py,sha256=9tOql42d00KfHpZYkLLGEAOiy8iRbIzsknldCyICwU0,12063
 outerbounds/command_groups/workstations_cli.py,sha256=f3gwHMZPHzeOcGj5VfC5tZZA18JQhFzy2LRGzqAosOk,19286
 outerbounds/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 outerbounds/utils/kubeconfig.py,sha256=l1mUP1j9VIq3fsffi5bJ1Nk-hYlwd1dIqkpj7DvVS1E,7936
-outerbounds/utils/metaflowconfig.py,sha256=_Khqzu0KE6X05KkVbb39GXN6CFpG2WRr6Xs35pT2l7A,3299
+outerbounds/utils/metaflowconfig.py,sha256=HgaDmK3F97rppfGUdysS1Zppe28ERTLV_HcB5IuPpV4,2631
 outerbounds/utils/schema.py,sha256=Ht_Yf5uoKO0m36WXHZLSPmWPH6EFWXfZDQsiAUquc5k,2160
-outerbounds-0.3.52rc6.dist-info/METADATA,sha256=RZn_J3Jy1JYymPhAygV-QcheRb-GEVN_VPx8jzFzRSw,1367
-outerbounds-0.3.52rc6.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-outerbounds-0.3.52rc6.dist-info/entry_points.txt,sha256=7ye0281PKlvqxu15rjw60zKg2pMsXI49_A8BmGqIqBw,47
-outerbounds-0.3.52rc6.dist-info/RECORD,,
+outerbounds-0.3.53rc1.dist-info/METADATA,sha256=uUkhPz_gBBdZGk4mA3B5PrwediF87wcbiMRxb9bPe_w,1364
+outerbounds-0.3.53rc1.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+outerbounds-0.3.53rc1.dist-info/entry_points.txt,sha256=7ye0281PKlvqxu15rjw60zKg2pMsXI49_A8BmGqIqBw,47
+outerbounds-0.3.53rc1.dist-info/RECORD,,