snapctl 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

snapctl/commands/application.py

@@ -0,0 +1,135 @@
+"""
+  Application CLI commands
+"""
+from typing import Union
+import requests
+from requests.exceptions import RequestException
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from snapctl.config.constants import SERVER_CALL_TIMEOUT, SNAPCTL_INPUT_ERROR, \
+    SNAPCTL_GAME_CREATE_ERROR, SNAPCTL_GAME_ENUMERATE_ERROR, \
+    HTTP_ERROR_DUPLICATE_GAME_NAME, SNAPCTL_GAME_CREATE_DUPLICATE_NAME_ERROR, \
+    HTTP_ERROR_GAME_LIMIT_REACHED, SNAPCTL_GAME_CREATE_LIMIT_ERROR
+from snapctl.utils.helper import snapctl_error, snapctl_success
+
+
+class Application:
+    """
+      CLI commands exposed for an Application
+    """
+    SUBCOMMANDS = ['create', 'enumerate']
+
+    def __init__(
+            self, *, subcommand: str, base_url: str, api_key: Union[str, None],
+            name: Union[str, None] = None
+    ) -> None:
+        self.subcommand: str = subcommand
+        self.base_url: str = base_url
+        self.api_key: Union[str, None] = api_key
+        self.name: Union[str, None] = name
+        # Validate input
+        self.validate_input()
+
+    def validate_input(self) -> None:
+        """
+          Validator
+        """
+        # Check API Key and Base URL
+        if not self.api_key or self.base_url == '':
+            snapctl_error(
+                message="Missing API Key.", code=SNAPCTL_INPUT_ERROR)
+        # Check subcommand
+        if not self.subcommand in Application.SUBCOMMANDS:
+            snapctl_error(
+                message="Invalid command. Valid commands are " +
+                f"{', '.join(Application.SUBCOMMANDS)}.",
+                code=SNAPCTL_INPUT_ERROR)
+        # Check commands
+        if self.subcommand == 'create':
+            if self.name is None or self.name == '':
+                snapctl_error(
+                    message="Missing application name.",
+                    code=SNAPCTL_INPUT_ERROR)
+
+    def create(self, no_exit: bool = False) -> bool:
+        """
+          Create an application
+        """
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Creating a new application on Snapser...', total=None)
+        try:
+            url = f"{self.base_url}/v1/snapser-api/games"
+            payload = {
+                'name': self.name
+            }
+            res = requests.post(
+                url, headers={'api-key': self.api_key},
+                json=payload, timeout=SERVER_CALL_TIMEOUT
+            )
+            if res.ok:
+                snapctl_success(
+                    message=f"Game {self.name} create successful",
+                    progress=progress, no_exit=no_exit)
+                return
+            response_json = res.json()
+            if "api_error_code" in response_json and "message" in response_json:
+                if response_json['api_error_code'] == HTTP_ERROR_GAME_LIMIT_REACHED:
+                    snapctl_error(
+                        message=f"Game {self.name} already exists.",
+                        code=SNAPCTL_GAME_CREATE_LIMIT_ERROR, progress=progress)
+                if response_json['api_error_code'] == HTTP_ERROR_DUPLICATE_GAME_NAME:
+                    snapctl_error(
+                        message=f"Game {self.name} already exists.",
+                        code=SNAPCTL_GAME_CREATE_DUPLICATE_NAME_ERROR, progress=progress)
+            snapctl_error(
+                message=f'Server error: {response_json}',
+                code=SNAPCTL_GAME_CREATE_ERROR, progress=progress)
+        except RequestException as e:
+            snapctl_error(
+                message=f"Exception: Unable to download the SDK {e}",
+                code=SNAPCTL_GAME_CREATE_ERROR, progress=progress)
+        finally:
+            progress.stop()
+        snapctl_error(
+            message='Failed to create an application.',
+            code=SNAPCTL_GAME_CREATE_ERROR, progress=progress)
+
+    def enumerate(self) -> bool:
+        """
+          Enumerate all applications
+        """
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
+        progress.add_task(
+            description='Enumerating all your applications on Snapser...', total=None)
+        try:
+            url = f"{self.base_url}/v1/snapser-api/games"
+            res = requests.get(
+                url, headers={'api-key': self.api_key},
+                timeout=SERVER_CALL_TIMEOUT
+            )
+            response_json = res.json()
+            if res.ok and 'games' in response_json:
+                snapctl_success(
+                    message=response_json['games'], progress=progress)
+            snapctl_error(
+                message='Unable to enumerate applications.',
+                code=SNAPCTL_GAME_ENUMERATE_ERROR, progress=progress)
+        except RequestException as e:
+            snapctl_error(
+                message=f"Exception: Unable to enumerate applications {e}",
+                code=SNAPCTL_GAME_ENUMERATE_ERROR, progress=progress)
+        finally:
+            progress.stop()
+        snapctl_error(
+            message='Failed to enumerate applications.',
+            code=SNAPCTL_GAME_ENUMERATE_ERROR, progress=progress)

snapctl/commands/byows.py

@@ -20,6 +20,7 @@ from snapctl.config.constants import SERVER_CALL_TIMEOUT, SNAPCTL_INPUT_ERROR, \
 from snapctl.utils.helper import snapctl_error, snapctl_success, get_dot_snapser_dir
 from snapctl.utils.echo import info, warning
 
+
 class Byows:
     """
       CLI commands exposed for a Bring your own Workstation
@@ -106,7 +107,7 @@ class Byows:
         env_vars = []
 
         for snap_id in snap_ids:
-            upper_id = snap_id.upper()
+            upper_id = snap_id.upper().replace("-", "_")
             env_vars.append(f"SNAPEND_{upper_id}_GRPC_URL=localhost:{port}")
             env_vars.append(
                 f"SNAPEND_{upper_id}_HTTP_URL=http://localhost:{port}")
@@ -128,7 +129,7 @@ class Byows:
         env_lines = []
 
         for snap_id in snap_ids:
-            upper_id = snap_id.upper()
+            upper_id = snap_id.upper().replace("-", "_")
             env_lines.append(
                 f"export SNAPEND_{upper_id}_GRPC_URL=localhost:{port}")
             env_lines.append(
@@ -393,7 +394,7 @@ class Byows:
                     self._handle_signal))
                 if hasattr(signal, "SIGBREAK"):
                     signal.signal(signal.SIGBREAK,
-                    functools.partial(self._handle_signal))
+                                  functools.partial(self._handle_signal))
                 # Set up port forward
                 self._setup_port_forward(
                     response_json['proxyPrivateKey'],
@@ -416,7 +417,8 @@ class Byows:
                 code=SNAPCTL_BYOWS_ATTACH_ERROR, progress=progress)
         except HTTPError as http_err:
             snapctl_error(
-                message=Byows._format_portal_http_error("Attach failed.", http_err, res),
+                message=Byows._format_portal_http_error(
+                    "Attach failed.", http_err, res),
                 code=SNAPCTL_BYOWS_ATTACH_ERROR, progress=progress)
         except RequestException as e:
             snapctl_error(

snapctl/commands/game.py

@@ -1,5 +1,5 @@
 """
-  Snapend CLI commands
+  Game CLI commands
 """
 from typing import Union
 import requests
@@ -91,7 +91,7 @@ class Game:
                 code=SNAPCTL_GAME_CREATE_ERROR, progress=progress)
         except RequestException as e:
             snapctl_error(
-                message=f"Exception: Unable to download the SDK {e}",
+                message=f"Exception: Unable to create game {e}",
                 code=SNAPCTL_GAME_CREATE_ERROR, progress=progress)
         finally:
             progress.stop()
@@ -126,7 +126,7 @@ class Game:
                 code=SNAPCTL_GAME_ENUMERATE_ERROR, progress=progress)
         except RequestException as e:
             snapctl_error(
-                message=f"Exception: Unable to update your snapend {e}",
+                message=f"Exception: Unable to enumerate games {e}",
                 code=SNAPCTL_GAME_ENUMERATE_ERROR, progress=progress)
         finally:
             progress.stop()

snapctl/commands/snapend.py

@@ -18,12 +18,16 @@ from snapctl.config.constants import SERVER_CALL_TIMEOUT, SNAPCTL_INPUT_ERROR, \
     SNAPCTL_SNAPEND_APPLY_ERROR, SNAPCTL_SNAPEND_PROMOTE_SERVER_ERROR, \
     SNAPCTL_SNAPEND_PROMOTE_TIMEOUT_ERROR, SNAPCTL_SNAPEND_PROMOTE_ERROR, \
     SNAPCTL_SNAPEND_DOWNLOAD_ERROR, SNAPCTL_SNAPEND_UPDATE_TIMEOUT_ERROR, \
-    SNAPCTL_SNAPEND_UPDATE_ERROR, SNAPCTL_SNAPEND_STATE_ERROR, HTTP_ERROR_SNAPEND_MANIFEST_MISMATCH, \
-    SNAPCTL_SNAPEND_APPLY_MANIFEST_MISMATCH_ERROR
+    SNAPCTL_SNAPEND_UPDATE_ERROR, SNAPCTL_SNAPEND_STATE_ERROR, \
+    HTTP_ERROR_SNAPEND_MANIFEST_MISMATCH, HTTP_ERROR_CLUSTER_UPDATE_IN_PROGRESS, \
+    SNAPCTL_SNAPEND_APPLY_MANIFEST_MISMATCH_ERROR, HTTP_ERROR_GAME_NOT_FOUND, \
+    SNAPCTL_SNAPEND_CREATE_SERVER_ERROR, SNAPCTL_SNAPEND_CREATE_TIMEOUT_ERROR, \
+    SNAPCTL_SNAPEND_CREATE_ERROR, HTTP_CONFLICT
 from snapctl.config.hashes import PROTOS_TYPES, CLIENT_SDK_TYPES, SERVER_SDK_TYPES, \
     SNAPEND_MANIFEST_TYPES, SDK_TYPES, SDK_ACCESS_AUTH_TYPE_LOOKUP
 from snapctl.utils.echo import error, success, info
 from snapctl.utils.helper import snapctl_error, snapctl_success
+from snapctl.utils.exceptions import SnapendDownloadException
 
 
 class Snapend:
@@ -31,7 +35,7 @@ class Snapend:
       CLI commands exposed for a Snapend
     """
     SUBCOMMANDS = [
-        'enumerate', 'clone', 'apply',
+        'enumerate', 'create', 'clone', 'apply',
         'download', 'update', 'state'
     ]
     DOWNLOAD_CATEGORY = [
@@ -79,8 +83,8 @@ class Snapend:
         self.api_key: str = api_key
         self.snapend_id: str = snapend_id
         self.game_id: Union[str, None] = game_id
-        self.name: str = name
-        self.env: str = env
+        self.name: Union[str, None] = name
+        self.env: Union[str, None] = env
         self.manifest_path_filename: Union[str, None] = manifest_path_filename
         self.force: bool = force
         self.category: str = category
@@ -103,6 +107,9 @@ class Snapend:
         self.byogs_list: Union[str, None] = Snapend._make_byogs_list(
             byogs) if byogs else None
         self.blocking: bool = blocking
+        # Backup variables
+        self.manifest_name: Union[str, None] = None
+        self.manifest_environment: Union[str, None] = None
         # Validate input
         self.validate_input()
 
@@ -252,6 +259,18 @@ class Snapend:
             res = requests.get(
                 url, headers={'api-key': self.api_key}, timeout=SERVER_CALL_TIMEOUT
             )
+            if not res.ok:
+                # Handle known conflict case
+                if res.status_code == HTTP_CONFLICT:
+                    response = res.json()
+                    if (
+                        response.get(
+                            "api_error_code") == HTTP_ERROR_CLUSTER_UPDATE_IN_PROGRESS
+                    ):
+                        raise SnapendDownloadException(
+                            "Snapend update is in progress. Please try again later.")
+                return False
+
             fn: str = ''
             if self.category == 'admin-settings':
                 fn = f"snapser-{self.snapend_id}-admin-settings.json"
@@ -277,15 +296,14 @@ class Snapend:
                 file_save_path = os.path.join(self.out_path, fn)
             else:
                 file_save_path = os.path.join(os.getcwd(), fn)
-            if res.ok:
-                content: bytes = res.content
-                with open(file_save_path, "wb") as file:
-                    if self.category in ['admin-settings']:
-                        content = json.loads(res.content)
-                        json.dump(content, file, indent=4)
-                    else:
-                        file.write(res.content)
-                return True
+
+            with open(file_save_path, "wb") as file:
+                if self.category in ['admin-settings']:
+                    content = json.loads(res.content)
+                    json.dump(content, file, indent=4)
+                else:
+                    file.write(res.content)
+            return True
         except RequestException as e:
             info(
                 f"Exception: Unable to download {self.category}. Reason: {e}"
@@ -316,6 +334,59 @@ class Snapend:
             format_str = format_str[:-2]
         return format_str
 
+    # Backup variables
+
+    def setup_manifest_name_and_env_vars(self) -> bool:
+        """
+        Read a manifest (JSON or YAML) and saves the name and environment.
+        Supports extensions: .json, .yaml, .yml
+        If the extension is unknown, tries JSON then YAML.
+        """
+        def parse_json(s: str):
+            return json.loads(s)
+
+        def parse_yaml(s: str):
+            try:
+                import yaml  # type: ignore
+            except ImportError as e:
+                raise RuntimeError(
+                    "YAML file provided but PyYAML is not installed. "
+                    "Install with: pip install pyyaml"
+                ) from e
+            return yaml.safe_load(s)
+
+        with open(self.manifest_path_filename, "r", encoding="utf-8") as f:
+            text = f.read()
+
+        ext = os.path.splitext(self.manifest_path_filename)[1].lower()
+        if ext == ".json":
+            parsers = (parse_json, parse_yaml)
+        elif ext in (".yaml", ".yml"):
+            parsers = (parse_yaml, parse_json)
+        else:
+            parsers = (parse_json, parse_yaml)
+
+        last_err = None
+        data = None
+        for parser in parsers:
+            try:
+                data = parser(text)
+                break
+            except Exception as e:
+                last_err = e
+
+        if data is None:
+            return False
+        if not isinstance(data, dict):
+            return False
+
+        try:
+            self.manifest_name = str(data["name"])
+            self.manifest_environment = str(data["environment"])
+        except KeyError as e:
+            pass
+        return False
+
     # Validate input
     def validate_input(self) -> None:
         """
@@ -335,26 +406,51 @@ class Snapend:
         if self.subcommand == 'enumerate':
             if not self.game_id:
                 snapctl_error(
-                    message="Missing required parameter: game_id",
+                    message="Missing required parameter: application-id",
                     code=SNAPCTL_INPUT_ERROR)
-        elif self.subcommand == 'clone':
+        elif self.subcommand == 'create':
             if not self.game_id:
                 snapctl_error(
-                    message="Missing required parameter: game_id",
+                    message="Missing required parameter: application-id",
                     code=SNAPCTL_INPUT_ERROR)
-            if not self.name:
+            if not self.manifest_path_filename:
                 snapctl_error(
-                    message="Missing required parameter: name",
+                    message="Missing required parameter: manifest_path_filename",
                     code=SNAPCTL_INPUT_ERROR)
-            if not self.env:
+            if not os.path.isfile(self.manifest_path_filename):
                 snapctl_error(
-                    message="Missing required parameter: env", code=SNAPCTL_INPUT_ERROR)
-            if self.env.upper() not in Snapend.ENV_TYPES:
+                    message=f"Invalid path {self.manifest_path_filename}. " +
+                    "Please enter a valid path to the manifest file",
+                    code=SNAPCTL_INPUT_ERROR
+                )
+            if not self.manifest_file_name:
                 snapctl_error(
-                    message="Invalid environment. Valid environments are " +
+                    message="Invalid manifest file. Supported formats are .json, .yml, .yaml",
+                    code=SNAPCTL_INPUT_ERROR)
+            self.setup_manifest_name_and_env_vars()
+            if not self.name and not self.manifest_name:
+                snapctl_error(
+                    message="Missing name parameter or name in manifest is required for " +
+                    "create command.",
+                    code=SNAPCTL_INPUT_ERROR)
+            if not self.env and not self.manifest_environment:
+                snapctl_error(
+                    message="Missing environment parameter or environment in manifest is " +
+                    "required for create command.",
+                    code=SNAPCTL_INPUT_ERROR)
+            if self.env and self.env.upper() not in Snapend.ENV_TYPES and \
+                    self.manifest_environment not in Snapend.ENV_TYPES:
+                env_str = 'Invalid environment argument.' if not self.env else 'Invalid environment in manifest.'
+                snapctl_error(
+                    message=f"{env_str}. Valid environments are " +
                     f"{', '.join(Snapend.ENV_TYPES)}.",
                     code=SNAPCTL_INPUT_ERROR
                 )
+        elif self.subcommand == 'clone':
+            if not self.game_id:
+                snapctl_error(
+                    message="Missing required parameter: application-id",
+                    code=SNAPCTL_INPUT_ERROR)
             if not self.manifest_path_filename:
                 snapctl_error(
                     message="Missing required parameter: manifest_path_filename",
@@ -365,6 +461,29 @@ class Snapend:
                     "Please enter a valid path to the manifest file",
                     code=SNAPCTL_INPUT_ERROR
                 )
+            if not self.manifest_file_name:
+                snapctl_error(
+                    message="Invalid manifest file. Supported formats are .json, .yml, .yaml",
+                    code=SNAPCTL_INPUT_ERROR)
+            self.setup_manifest_name_and_env_vars()
+            if not self.name and not self.manifest_name:
+                snapctl_error(
+                    message="Missing name parameter or name in manifest is required for " +
+                    "create command.",
+                    code=SNAPCTL_INPUT_ERROR)
+            if not self.env and not self.manifest_environment:
+                snapctl_error(
+                    message="Missing environment parameter or environment in manifest is " +
+                    "required for create command.",
+                    code=SNAPCTL_INPUT_ERROR)
+            if self.env and self.env.upper() not in Snapend.ENV_TYPES and \
+                    self.manifest_environment not in Snapend.ENV_TYPES:
+                env_str = 'Invalid environment argument.' if not self.env else 'Invalid environment in manifest.'
+                snapctl_error(
+                    message=f"{env_str}. Valid environments are " +
+                    f"{', '.join(Snapend.ENV_TYPES)}.",
+                    code=SNAPCTL_INPUT_ERROR
+                )
         elif self.subcommand == 'apply':
             if not self.manifest_path_filename:
                 snapctl_error(
@@ -516,7 +635,7 @@ class Snapend:
             message="Unable to enumerate snapends.",
             code=SNAPCTL_SNAPEND_ENUMERATE_ERROR, progress=progress)
 
-    def clone(self) -> None:
+    def create(self) -> None:
         """
           Create a Snapend from a manifest
         """
@@ -526,6 +645,84 @@ class Snapend:
             transient=True,
         )
         progress.start()
+        progress.add_task(
+            description='Creating your snapend from the manifest...', total=None)
+        try:
+            with open(self.manifest_path_filename, 'rb') as file:
+                files = {'snapend-manifest': file}
+                payload = {
+                    'game_id': self.game_id,
+                    'name': self.name if self.name else self.manifest_name,
+                    'env': self.env.upper() if self.env else self.manifest_environment.upper(),
+                    'ext': self.manifest_file_name.split('.')[-1]
+                }
+                url = f"{self.base_url}/v1/snapser-api/snapends/snapend-manifest"
+                res = requests.post(
+                    url, headers={'api-key': self.api_key},
+                    files=files, data=payload, timeout=SERVER_CALL_TIMEOUT
+                )
+                if res.ok:
+                    # extract the cluster ID
+                    response = res.json()
+                    if 'cluster' not in response or 'id' not in response['cluster']:
+                        snapctl_error(
+                            message='Server Error. Unable to get a Snapend ID. ' +
+                            'Please try again in sometime.',
+                            code=SNAPCTL_SNAPEND_CREATE_SERVER_ERROR,
+                            progress=progress
+                        )
+                    self._assign_snapend_id(response['cluster']['id'])
+                    info(f"Cluster ID assigned: {response['cluster']['id']}")
+                    if self.blocking:
+                        snapctl_success(
+                            message='Snapend create initiated.',
+                            progress=progress,
+                            no_exit=True
+                        )
+                        status = self._blocking_get_status()
+                        # Fetch the new manifest
+                        if status is True:
+                            # TODO: Uncomment this if we want to do an auto download
+                            # self._setup_for_download(
+                            #     self.manifest_file_name.split('.')[-1])
+                            # self._execute_download()
+                            snapctl_success(
+                                message='Snapend create successful. Do not forget to download the latest manifest.',
+                                progress=progress)
+                        snapctl_error(
+                            message='Snapend create has been initiated but the Snapend is not up yet.' +
+                            'Please try checking the status of the Snapend in some time',
+                            code=SNAPCTL_SNAPEND_CREATE_TIMEOUT_ERROR,
+                            progress=progress
+                        )
+                    snapctl_success(
+                        message="Snapend create has been initiated. " +
+                        "You can check the status using " +
+                        "`snapctl snapend state --snapend-id" +
+                        f"{response['cluster']['id']}`",
+                        progress=progress
+                    )
+        except RequestException as e:
+            snapctl_error(
+                message=f"Unable to create a snapend from a manifest. {e}",
+                code=SNAPCTL_SNAPEND_CREATE_ERROR, progress=progress
+            )
+        finally:
+            progress.stop()
+        snapctl_error(
+            message='Unable to create a snapend from a manifest.',
+            code=SNAPCTL_SNAPEND_CREATE_ERROR, progress=progress)
+
+    def clone(self) -> None:
+        """
+          Clone a Snapend from a manifest
+        """
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        )
+        progress.start()
         progress.add_task(
             description='Cloning your snapend from the manifest...', total=None)
         try:
@@ -533,8 +730,8 @@ class Snapend:
                 files = {'snapend-manifest': file}
                 payload = {
                     'game_id': self.game_id,
-                    'name': self.name,
-                    'env': self.env.upper(),
+                    'name': self.name if self.name else self.manifest_name,
+                    'env': self.env.upper() if self.env else self.manifest_environment.upper(),
                     'ext': self.manifest_file_name.split('.')[-1]
                 }
                 url = f"{self.base_url}/v1/snapser-api/snapends/snapend-manifest"
@@ -591,7 +788,7 @@ class Snapend:
         finally:
             progress.stop()
         snapctl_error(
-            message='Unable to apply the manifest.',
+            message='Unable to clone from the manifest.',
             code=SNAPCTL_SNAPEND_CLONE_ERROR, progress=progress)
 
     def apply(self) -> None:
@@ -663,10 +860,25 @@ class Snapend:
                 else:
                     if "api_error_code" in response and "message" in response:
                         if response['api_error_code'] == HTTP_ERROR_SNAPEND_MANIFEST_MISMATCH:
+                            msg = 'Remote manifest does not match the manifest in the ' + \
+                                'applied_configuration field.'
                             snapctl_error(
-                                message='Remote manifest does not match the manifest in the applied_configuration field.',
+                                message=msg,
                                 code=SNAPCTL_SNAPEND_APPLY_MANIFEST_MISMATCH_ERROR, progress=progress
                             )
+                        elif response['api_error_code'] == HTTP_ERROR_GAME_NOT_FOUND:
+                            msg = 'Game not found. Did you mean to use the clone command to ' + \
+                                'create a new snapend?'
+                            snapctl_error(
+                                message=msg,
+                                code=SNAPCTL_SNAPEND_APPLY_ERROR, progress=progress
+                            )
+                        elif response['api_error_code'] == HTTP_ERROR_CLUSTER_UPDATE_IN_PROGRESS:
+                            msg = 'Snapend update is in progress. Please try again later.'
+                            snapctl_error(
+                                message=msg,
+                                code=SNAPCTL_SNAPEND_APPLY_ERROR, progress=progress
+                            )
         except RequestException as e:
             snapctl_error(
                 message=f"Unable to apply the manifest snapend. {e}",
@@ -775,6 +987,12 @@ class Snapend:
                     f"{self.category} saved at {self.out_path}",
                     progress=progress
                 )
+        except SnapendDownloadException as e:
+            snapctl_error(
+                message=str(e),
+                code=SNAPCTL_SNAPEND_DOWNLOAD_ERROR,
+                progress=progress
+            )
         except RequestException as e:
             snapctl_error(
                 message=f"Unable to download {self.category}. Reason: {e}",