thestage 0.5.46__py3-none-any.whl → 0.5.47__py3-none-any.whl

thestage/services/clients/thestage_api/dtos/validate_token_response.py

@@ -0,0 +1,11 @@
+from typing import Optional, List, Dict
+
+from pydantic import Field, BaseModel, ConfigDict
+
+from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse, TheStageBasePaginatedResponse
+
+
+class ValidateTokenResponse(TheStageBaseResponse):
+    model_config = ConfigDict(use_enum_values=True)
+
+    allowedCliCommands: Optional[Dict[str, bool]] = Field(default={}, alias='allowedCliCommands')

thestage/services/config_provider/config_provider.py

@@ -2,50 +2,40 @@ import typer
 
 import json
 import os
-from json import JSONDecodeError
 from pathlib import Path
 from typing import Optional, Dict, Any
 
-from thestage.exceptions.file_system_exception import FileSystemException
+from thestage.cli_command import CliCommand, CliCommandAvailability, ALWAYS_AVAILABLE_COMMANDS
+from thestage.services.clients.thestage_api.dtos.validate_token_response import ValidateTokenResponse
 from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.helpers.ssh_util import parse_private_key
 from thestage.services.connect.dto.remote_server_config import RemoteServerConfig
 from thestage.services.filesystem_service import FileSystemService
 from thestage.services.project.dto.project_config import ProjectConfig
-from thestage.config import THESTAGE_CONFIG_DIR, THESTAGE_CONFIG_FILE, THESTAGE_AUTH_TOKEN, THESTAGE_API_URL
-
-class ConfigProvider():
-    # path to current physical subject we work with (project / etc) - might be passed explicitly
-    _local_path: Optional[Path] = None
-    _local_config_path: Optional[Path] = None
-    _global_config_path: Optional[Path] = None
-    _global_config_file: Optional[Path] = None
+from thestage.config import THESTAGE_CONFIG_DIR, THESTAGE_CONFIG_FILE, THESTAGE_AUTH_TOKEN, THESTAGE_API_URL, \
+    config_storage
+
+
+class ConfigProvider:
     _file_system_service = FileSystemService
 
 
     def __init__(
             self,
-            local_path: Optional[str] = None,
+            file_system_service: FileSystemService,
     ):
-        self._file_system_service = FileSystemService()
-        if local_path:
-            self._local_path = self._file_system_service.get_path(directory=local_path, auto_create=False)
-
-        self._local_config_path = self._local_path.joinpath(THESTAGE_CONFIG_DIR)
-
-        home_dir = self._file_system_service.get_home_path()
-        self._global_config_path = home_dir.joinpath(THESTAGE_CONFIG_DIR)
+        self._file_system_service = file_system_service
 
-        if self._global_config_path:
-            if not self._global_config_path.exists():
-                self._file_system_service.create_if_not_exists_dir(self._global_config_path)
+        global_config_path = self.get_global_config_path()
+        if not global_config_path.exists():
+            self._file_system_service.create_if_not_exists_dir(global_config_path)
 
-        self._global_config_file = self._global_config_path.joinpath(THESTAGE_CONFIG_FILE)
-        if not self._global_config_file.exists():
-            self._file_system_service.create_if_not_exists_file(self._global_config_file)
+        global_config_file = self.get_global_config_file()
+        self._file_system_service.create_if_not_exists_file(global_config_file)
 
 
-    def get_full_config(self) -> ConfigEntity:
+    # must be called right after the app is started
+    def build_config(self) -> ConfigEntity:
         config_values = {}
 
         config_from_env = {}
@@ -58,35 +48,36 @@ class ConfigProvider():
         if config_from_env:
             self.__update_config_values_dict(values_to_update=config_values, new_values=config_from_env)
 
-        config_from_file = self._file_system_service.read_config_file(self._global_config_file)
+        config_from_file = self._file_system_service.read_config_file(self.get_global_config_file())
         if config_from_file:
             self.__update_config_values_dict(values_to_update=config_values, new_values=config_from_file)
 
         config = ConfigEntity.model_validate(config_values)
+        config.runtime.config_global_path = str(self.get_global_config_path())
 
-        if self._local_path:
-            config.runtime.working_directory = str(self._local_path)
-        if self._global_config_path and not config.runtime.config_global_path:
-            config.runtime.config_global_path = str(self._global_config_path)
+        config_storage.APP_CONFIG = config
 
         return config
 
 
+    def get_config(self) -> ConfigEntity:
+        if not config_storage.APP_CONFIG:
+            raise Exception('Config storage was not initialized')
+        return config_storage.APP_CONFIG
+
+
     def save_project_config(self, project_config: ProjectConfig):
-        project_data_dirpath = self.__get_project_config_path()
-        if not project_data_dirpath.exists():
-            self._file_system_service.create_if_not_exists_dir(project_data_dirpath)
+        project_data_dirpath = self.__get_project_config_path(with_file=False)
+        self._file_system_service.create_if_not_exists_dir(project_data_dirpath)
 
         project_data_filepath = self.__get_project_config_path(with_file=True)
-        if not project_data_filepath.exists():
-            self._file_system_service.create_if_not_exists_file(project_data_filepath)
+        self._file_system_service.create_if_not_exists_file(project_data_filepath)
 
-        project_config_path = self.__get_project_config_path(with_file=True)
-        self.__save_config_file(data=project_config.model_dump(), file_path=project_config_path)
+        self.__save_config_file(data=project_config.model_dump(), file_path=project_data_filepath)
 
 
     def save_project_deploy_ssh_key(self, deploy_ssh_key: str, project_slug: str, project_id: int) -> str:
-        deploy_key_dirpath = self._global_config_path.joinpath('project_deploy_keys')
+        deploy_key_dirpath = self.get_global_config_path().joinpath('project_deploy_keys')
         self._file_system_service.create_if_not_exists_dir(deploy_key_dirpath)
 
         deploy_key_filepath = deploy_key_dirpath.joinpath(f'project_deploy_key_{project_id}_{project_slug}')
@@ -115,13 +106,13 @@ class ConfigProvider():
 
     def __get_project_config_path(self, with_file: bool = False) -> Path:
         if with_file:
-            return self._local_config_path.joinpath('project.json')
+            return Path(self.get_config().runtime.working_directory).joinpath(THESTAGE_CONFIG_DIR).joinpath('project.json')
         else:
-            return self._local_config_path
+            return Path(self.get_config().runtime.working_directory).joinpath(THESTAGE_CONFIG_DIR)
 
 
     def __get_remote_server_config_path(self) -> Path:
-        return self._global_config_path.joinpath('remote_server_config.json')
+        return self.get_global_config_path().joinpath('remote_server_config.json')
 
 
     def update_remote_server_config_entry(self, ip_address: str, ssh_key_path: Optional[Path]):
@@ -191,15 +182,18 @@ class ConfigProvider():
             json.dump(data, configfile, indent=1)
 
 
-    def save_config(self, config: ConfigEntity):
-        data: Dict[str, Any] = self._file_system_service.read_config_file(self._global_config_file)
+    def save_config(self):
+        config = self.get_config()
+        global_config_file = self.get_global_config_file()
+        data: Dict[str, Any] = self._file_system_service.read_config_file(global_config_file)
         data.update(config.model_dump(exclude_none=True, by_alias=True, exclude={'runtime', 'RUNTIME', 'daemon', 'DAEMON'}))
-        self.__save_config_file(data=data, file_path=self._global_config_file)
+        self.__save_config_file(data=data, file_path=global_config_file)
 
 
     def clear_config(self, ):
-        if self._global_config_path and self._global_config_path.exists():
-            self._file_system_service.remove_folder(str(self._global_config_path))
+        global_config_path = self.get_global_config_path()
+        if global_config_path.exists():
+            self._file_system_service.remove_folder(str(global_config_path))
 
         os.unsetenv('THESTAGE_CONFIG_DIR')
         os.unsetenv('THESTAGE_CONFIG_FILE')
@@ -207,3 +201,37 @@ class ConfigProvider():
         os.unsetenv('THESTAGE_API_URL')
         os.unsetenv('THESTAGE_LOG_FILE')
         os.unsetenv('THESTAGE_AUTH_TOKEN')
+
+
+    def update_config(self, updated_config: ConfigEntity):
+        config_storage.APP_CONFIG = updated_config
+
+    def get_global_config_path(self) -> Path:
+        home_dir = self._file_system_service.get_home_path()
+        return home_dir.joinpath(THESTAGE_CONFIG_DIR)
+
+    def get_global_config_file(self) -> Path:
+        return self.get_global_config_path().joinpath(THESTAGE_CONFIG_FILE)
+
+
+    def update_allowed_commands_and_is_token_valid(self, validate_token_response: ValidateTokenResponse):
+        config = self.get_config()
+        for cli_command_item in CliCommand:
+            is_command_available = validate_token_response.allowedCliCommands.get(cli_command_item)
+            command_availability = CliCommandAvailability.DEPRECATED
+
+            if cli_command_item in ALWAYS_AVAILABLE_COMMANDS:
+                command_availability = CliCommandAvailability.ALLOWED
+            else:
+                if is_command_available is True:
+                    command_availability = CliCommandAvailability.ALLOWED
+                if is_command_available is False:
+                    command_availability = CliCommandAvailability.RESTRICTED
+            config.runtime.allowed_commands.update({cli_command_item: command_availability})
+            config.runtime.is_token_valid = validate_token_response.is_success
+        self.update_config(config)
+
+
+    def is_cli_command_allowed(self, cli_command: CliCommand) -> bool:
+        config = self.get_config()
+        return True if config.runtime.allowed_commands.get(cli_command) == CliCommandAvailability.ALLOWED else False

thestage/services/connect/connect_service.py

@@ -1,6 +1,8 @@
 from typing import Optional
 import typer
 
+from thestage.cli_command import CliCommand
+from thestage.cli_command_helper import check_command_permission
 from thestage.i18n.translation import __
 from thestage.services.clients.thestage_api.core.http_client_exception import HttpClientException
 from thestage.services.clients.thestage_api.dtos.enums.container_status import DockerContainerStatus
@@ -11,7 +13,6 @@ from thestage.helpers.error_handler import error_handler
 from thestage.services.clients.thestage_api.api_client import TheStageApiClient
 from thestage.services.clients.thestage_api.dtos.enums.task_status import TaskStatus
 from thestage.services.clients.thestage_api.dtos.instance_rented_response import InstanceRentedDto
-from thestage.services.config_provider.config_provider import ConfigProvider
 from thestage.services.container.container_service import ContainerService
 from thestage.services.instance.instance_service import InstanceService
 from thestage.services.logging.logging_service import LoggingService
@@ -26,14 +27,12 @@ class ConnectService(AbstractService):
 
     def __init__(
             self,
-            config_provider: ConfigProvider,
             thestage_api_client: TheStageApiClient,
             instance_service: InstanceService,
             container_service: ContainerService,
             logging_service: LoggingService,
     ):
         super(ConnectService, self).__init__(
-            config_provider=config_provider,
         )
         self.__thestage_api_client = thestage_api_client
         self.__instance_service = instance_service
@@ -48,24 +47,22 @@ class ConnectService(AbstractService):
             username: Optional[str],
             private_key_path: Optional[str],
     ):
-        config = self._config_provider.get_full_config()
-
         try:
-            instance_selfhosted = self.__thestage_api_client.get_selfhosted_instance(token=config.main.thestage_auth_token, instance_slug=uid)
+            instance_selfhosted = self.__thestage_api_client.get_selfhosted_instance(instance_slug=uid)
         except HttpClientException as e:
             if e.get_status_code() == 403:
                 typer.echo("Missing permission to view self-hosted instances")
             instance_selfhosted = None
 
         try:
-            instance_rented = self.__thestage_api_client.get_rented_instance(token=config.main.thestage_auth_token, instance_slug=uid)
+            instance_rented = self.__thestage_api_client.get_rented_instance(instance_slug=uid)
         except HttpClientException as e:
             if e.get_status_code() == 403:
                 typer.echo("Missing permission to view rented instances")
             instance_rented = None
 
         try:
-            container = self.__thestage_api_client.get_container(token=config.main.thestage_auth_token, container_slug=uid, )
+            container = self.__thestage_api_client.get_container(container_slug=uid,)
         except HttpClientException as e:
             if e.get_status_code() == 403:
                 typer.echo("Missing permission to view containers")
@@ -74,7 +71,7 @@ class ConnectService(AbstractService):
         task: Optional[TaskDto] = None
         if uid.isdigit():
             try:
-                task_view_response = self.__thestage_api_client.get_task(token=config.main.thestage_auth_token, task_id=int(uid))
+                task_view_response = self.__thestage_api_client.get_task(task_id=int(uid))
             except HttpClientException as e:
                 if e.get_status_code() == 403:
                     typer.echo("Missing permission to view tasks")
@@ -114,27 +111,27 @@ class ConnectService(AbstractService):
             raise typer.Exit(code=1)
 
         if rented_presence:
+            check_command_permission(CliCommand.INSTANCE_RENTED_CONNECT)
             typer.echo("Connecting to rented instance...")
             self.__instance_service.connect_to_rented_instance(
                 instance_rented_slug=uid,
-                config=config,
                 input_ssh_key_path=private_key_path
             )
 
         if container_presence:
+            check_command_permission(CliCommand.CONTAINER_CONNECT)
             typer.echo("Connecting to docker container...")
             self.__container_service.connect_to_container(
-                config=config,
                 container_uid=uid,
                 username=username,
                 input_ssh_key_path=private_key_path
             )
 
         if selfhosted_presence:
+            check_command_permission(CliCommand.INSTANCE_SELF_HOSTED_CONNECT)
             typer.echo("Connecting to self-hosted instance...")
 
             self.__instance_service.connect_to_selfhosted_instance(
-                config=config,
                 selfhosted_instance_slug=uid,
                 username=username,
                 input_ssh_key_path=private_key_path
@@ -142,20 +139,15 @@ class ConnectService(AbstractService):
 
         if task_presence:
             typer.echo(__("Connecting to task..."))
-            self.__logging_service.stream_task_logs_with_controls(
-                config=config,
-                task_id=int(uid),
-            )
+            self.__logging_service.stream_task_logs_with_controls(task_id=int(uid))
 
 
     @error_handler()
     def upload_ssh_key(self, public_key_contents: str, instance_slug: Optional[str]):
-        config = self._config_provider.get_full_config()
-
         instance_rented: Optional[InstanceRentedDto] = None
         if instance_slug:
             try:
-                instance_rented = self.__thestage_api_client.get_rented_instance(token=config.main.thestage_auth_token, instance_slug=instance_slug)
+                instance_rented = self.__thestage_api_client.get_rented_instance(instance_slug=instance_slug)
             except HttpClientException as e:
                 instance_rented = None
 
@@ -167,7 +159,6 @@ class ConnectService(AbstractService):
         note_to_send: Optional[str] = None
 
         is_user_already_has_key_response = self.__thestage_api_client.is_user_has_ssh_public_key(
-            token=config.main.thestage_auth_token,
             public_key=public_key_contents
         )
 
@@ -187,7 +178,6 @@ class ConnectService(AbstractService):
 
         if is_adding_key_to_user:
             add_ssh_key_to_user_response = self.__thestage_api_client.add_public_ssh_key_to_user(
-                token=config.main.thestage_auth_token,
                 public_key=public_key_contents,
                 note=note_to_send
             )
@@ -196,7 +186,6 @@ class ConnectService(AbstractService):
 
         if instance_rented:
             self.__thestage_api_client.add_public_ssh_key_to_instance_rented(
-                token=config.main.thestage_auth_token,
                 instance_rented_id=instance_rented.id,
                 ssh_key_pair_id=ssh_key_pair_id
             )

thestage/services/container/container_service.py

@@ -2,7 +2,6 @@ from pathlib import Path
 from typing import List, Tuple, Optional, Dict
 
 import typer
-from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.entities.container import DockerContainerEntity
 from thestage.services.clients.thestage_api.dtos.container_param_request import DockerContainerActionRequestDto
 from thestage.services.clients.thestage_api.dtos.enums.container_pending_action import DockerContainerAction
@@ -23,6 +22,7 @@ from thestage.services.config_provider.config_provider import ConfigProvider
 class ContainerService(AbstractService):
 
     __thestage_api_client: TheStageApiClient = None
+    __config_provider: ConfigProvider = None
 
     def __init__(
             self,
@@ -31,9 +31,7 @@ class ContainerService(AbstractService):
             remote_server_service: RemoteServerService,
             file_system_service: FileSystemService,
     ):
-        super(ContainerService, self).__init__(
-            config_provider=config_provider
-        )
+        self.__config_provider = config_provider
         self.__thestage_api_client = thestage_api_client
         self.__remote_server_service = remote_server_service
         self.__file_system_service = file_system_service
@@ -42,13 +40,12 @@ class ContainerService(AbstractService):
     @error_handler()
     def print_container_list(
             self,
-            config: ConfigEntity,
             row: int,
             page: int,
             project_uid: Optional[str],
             statuses: List[str],
     ):
-        container_status_map = self.__thestage_api_client.get_container_business_status_map(config.main.thestage_auth_token)
+        container_status_map = self.__thestage_api_client.get_container_business_status_map()
 
         if not statuses:
             statuses = ({key: container_status_map[key] for key in [
@@ -77,7 +74,7 @@ class ContainerService(AbstractService):
 
         project_id: Optional[int] = None
         if project_uid:
-            project = self.__thestage_api_client.get_project_by_slug(slug=project_uid, token=config.main.thestage_auth_token)
+            project = self.__thestage_api_client.get_project_by_slug(slug=project_uid)
             project_id = project.id
 
         self.print(
@@ -87,7 +84,6 @@ class ContainerService(AbstractService):
                 'project_id': project_id,
             },
             mapper=ContainerMapper(),
-            config=config,
             headers=list(map(lambda x: x.alias, DockerContainerEntity.model_fields.values())),
             row=row,
             page=page,
@@ -99,7 +95,6 @@ class ContainerService(AbstractService):
     @error_handler()
     def get_list(
             self,
-            config: ConfigEntity,
             statuses: List[str],
             row: int = 5,
             page: int = 1,
@@ -107,7 +102,6 @@ class ContainerService(AbstractService):
     ) -> PaginatedEntityList[DockerContainerDto]:
 
         list = self.__thestage_api_client.get_container_list(
-            token=config.main.thestage_auth_token,
             statuses=statuses,
             page=page,
             limit=row,
@@ -119,12 +113,10 @@ class ContainerService(AbstractService):
     @error_handler()
     def get_container(
             self,
-            config: ConfigEntity,
             container_id: Optional[int] = None,
             container_slug: Optional[str] = None,
     ) -> Optional[DockerContainerDto]:
         return self.__thestage_api_client.get_container(
-            token=config.main.thestage_auth_token,
             container_id=container_id,
             container_slug=container_slug,
         )
@@ -154,13 +146,13 @@ class ContainerService(AbstractService):
 
         private_key_path = private_key_path_override
         if not private_key_path:
-            private_key_path = self._config_provider.get_valid_private_key_path_by_ip_address(ip_address)
+            private_key_path = self.__config_provider.get_valid_private_key_path_by_ip_address(ip_address)
             if private_key_path:
                 typer.echo(f'Using configured private key for {ip_address}: {private_key_path}')
             else:
                 typer.echo(f'Using SSH agent to connect to {ip_address}')
         else:
-            self._config_provider.update_remote_server_config_entry(ip_address, Path(private_key_path))
+            self.__config_provider.update_remote_server_config_entry(ip_address, Path(private_key_path))
             typer.echo(f'Updated private key path for {ip_address}: {private_key_path}')
 
         return username, ip_address, private_key_path
@@ -168,13 +160,11 @@ class ContainerService(AbstractService):
     @error_handler()
     def connect_to_container(
             self,
-            config: ConfigEntity,
             container_uid: str,
             username: Optional[str],
             input_ssh_key_path: Optional[str],
     ):
         container: Optional[DockerContainerDto] = self.get_container(
-            config=config,
             container_slug=container_uid,
         )
 
@@ -321,7 +311,6 @@ class ContainerService(AbstractService):
             container: DockerContainerDto,
             src_path: str,
             copy_only_folder_contents: bool,
-            config: ConfigEntity,
             destination_path: Optional[str] = None,
             username_param: Optional[str] = None,
     ):
@@ -344,8 +333,6 @@ class ContainerService(AbstractService):
             typer.echo(__("Cannot find matching container volume mapping for specified file path"))
             raise typer.Exit(1)
 
-
-
         self.__remote_server_service.download_data_from_container(
             ip_address=ip_address,
             username=username,
@@ -353,19 +340,16 @@ class ContainerService(AbstractService):
             instance_path=instance_path,
             copy_only_folder_contents=copy_only_folder_contents,
             private_key_path=private_key_path,
-            config=config,
         )
 
 
     @error_handler()
     def request_docker_container_action(
             self,
-            config: ConfigEntity,
             container_uid: str,
             action: DockerContainerAction,
     ):
         container: Optional[DockerContainerDto] = self.get_container(
-            config=config,
             container_slug=container_uid,
         )
         if not container:
@@ -383,7 +367,6 @@ class ContainerService(AbstractService):
             action=action,
         )
         result = self.__thestage_api_client.container_action(
-            token=config.main.thestage_auth_token,
             request_param=request_params,
         )
 

thestage/services/core_files/config_entity.py

@@ -1,16 +1,22 @@
-from typing import Optional
+from typing import Optional, Dict
 
 from pydantic import BaseModel, Field
 
+from thestage.cli_command import CliCommand, CliCommandAvailability
+
+
 # saved to file
 class MainConfigEntity(BaseModel):
     thestage_auth_token: Optional[str] = Field(None, alias='thestage_auth_token')
     thestage_api_url: Optional[str] = Field(None, alias='thestage_api_url')
 
+
 # not saved to file
 class RuntimeConfigEntity(BaseModel):
     working_directory: Optional[str] = Field(None, alias='working_directory')
     config_global_path: Optional[str] = Field(None, alias='config_global_path')
+    allowed_commands: Dict[CliCommand, CliCommandAvailability] = {}
+    is_token_valid: bool = Field(None, alias='is_token_valid')
 
 
 class ConfigEntity(BaseModel):

thestage/services/filesystem_service.py

@@ -126,8 +126,8 @@ class FileSystemService:
                     try:
                         if os.stat(path).st_size != 0:
                             result = json.load(file)
-                    except JSONDecodeError:
-                        pass
+                    except JSONDecodeError as e:
+                        raise Exception(f"Config file is malformed: {path}") from e
         except OSError:
             raise FileSystemException(f"Could not open config file: {path}")
         return result