holado 0.7.1__py3-none-any.whl → 0.8.1__py3-none-any.whl

holado_core/common/resource/persisted_method_to_call_manager.py

@@ -17,16 +17,31 @@ from holado_core.common.resource.persisted_data_manager import PersistedDataMana
 from holado_python.standard_library.typing import Typing
 from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado_core.common.tools.tools import Tools
+from holado.common.handlers.undefined import undefined_value, undefined_argument
+from holado_python.common.tools.datetime import DateTime
+from holado_db.tools.db.query.base.query_builder import DBCompareOperator
+from holado.common.handlers.enums import AutoNumber
 
 logger = logging.getLogger(__name__)
 
 
+class MethodCallStatus(AutoNumber):
+    Ready = ()
+    Completed = ()
+    Failed = ()
+    Expired = ()
+    
 
 class PersistedMethodToCallManager(PersistedDataManager):
-    def __init__(self, data_name="method", table_name="method_to_call", db_name="default"):
+    def __init__(self, scope_name, delete_on_success=True, delete_on_fail=False, delete_on_success_after_fail=False, expiration_try_counter=10, data_name="method", table_name="method_to_call", db_name="default"):
         super().__init__(data_name=data_name, table_name=table_name, 
                          table_sql_create=self._get_default_table_sql_create(table_name), 
                          db_name=db_name)
+        self.__scope_name = scope_name
+        self.__delete_on_success = delete_on_success
+        self.__delete_on_fail = delete_on_fail
+        self.__delete_on_success_after_fail = delete_on_fail
+        self.__expiration_try_counter = expiration_try_counter
     
     def initialize(self, resource_manager, expression_evaluator):
         super().initialize(resource_manager)
@@ -35,91 +50,183 @@ class PersistedMethodToCallManager(PersistedDataManager):
     def _get_default_table_sql_create(self, table_name):
         return f"""CREATE TABLE {table_name} (
                 id INTEGER PRIMARY KEY,
+                scope_name text NOT NULL,
                 function_qualname text NOT NULL,
-                self_getter text,
-                args text,
-                kwargs text,
+                self_getter TEXT,
+                args TEXT,
+                kwargs TEXT,
                 use text NOT NULL,
-                use_index integer NOT NULL
+                use_index integer NOT NULL,
+                created_at TEXT,
+                changed_at TEXT,
+                status TEXT,
+                try_counter INTEGER,
+                error TEXT,
+                do_delete_on_success INTEGER,
+                do_delete_on_fail INTEGER,
+                do_delete_on_success_after_fail INTEGER
             )"""
     
-    def add_function_to_call(self, function_qualname, args_list=None, kwargs_dict=None, use="default", use_index=0):
+    def add_function_to_call(self, function_qualname, args_list=None, kwargs_dict=None, use="default", use_index=0, add_if_exists=False, delete_on_success=undefined_argument, delete_on_fail=undefined_argument, delete_on_success_after_fail=undefined_argument):
         """Add a function to call.
         @param function_qualname: Qualified name of function
         @param args_list: List of function args (default: None)
         @param kwargs_dict: Dict of function kwargs (default: None)
         @param use: Define persistent usage. It usually corresponds to a specific scope.
         @param use_index: use index, useable to order the functions to call. By default all are 0. If set to None, it is automatically set to max(use_index)+1.
+        @param delete_on_success: If True, delete function after its success
+        @param delete_on_fail: If True, delete function after its fail
+        @param delete_on_success_after_fail: If True, delete function after its success even if it has previously failed
         """
-        self.add_method_to_call(function_qualname, None, args_list, kwargs_dict, use, use_index)
+        self.add_method_to_call(function_qualname, None, args_list, kwargs_dict, use, use_index, add_if_exists, delete_on_success, delete_on_fail, delete_on_success_after_fail)
     
-    def add_method_to_call(self, function_qualname, self_getter_eval_str, args_list=None, kwargs_dict=None, use="default", use_index=0):
+    def add_method_to_call(self, function_qualname, self_getter_eval_str, args_list=None, kwargs_dict=None, use="default", use_index=0, add_if_exists=False, delete_on_success=undefined_argument, delete_on_fail=undefined_argument, delete_on_success_after_fail=undefined_argument):
         """Add a method to call.
         @param function_qualname: Qualified name of function
         @param self_getter_eval_str: String to eval in order to get the self instance to use when calling method 
         @param args_list: List of function args (default: None)
         @param kwargs_dict: Dict of function kwargs (default: None)
         @param use: Define persistent usage. It usually corresponds to a specific scope.
-        @param use_index: use index, useable to order the functions to call. By default all are 0. If set to None, it is automatically set to max(use_index)+1.
+        @param use_index: Use index, useable to order the functions to call. By default all are 0. If set to None, it is automatically set to max(use_index)+1.
+        @param add_if_exists: Add if method already exists (default: False)
+        @param delete_on_success: If True, delete method after its success
+        @param delete_on_fail: If True, delete method after its fail
+        @param delete_on_success_after_fail: If True, delete method after its success even if it has previously failed
         """
-        if use_index is None:
-            use_index = self.__get_use_next_index(use)
-            
+        # Define persisted data that can define if method is already persisted
         data = {
+            'scope_name': self.__scope_name,
             'function_qualname': function_qualname,
             'self_getter': self_getter_eval_str,
             'use': use,
-            'use_index': use_index
             }
         if args_list is not None:
             data['args'] = json.dumps(args_list)
         if kwargs_dict is not None:
             data['kwargs'] = json.dumps(kwargs_dict)
-            
+        
+        # Return if data is already persisted and add_if_exists==True
+        filter_compare_data = [('status', DBCompareOperator.In, [MethodCallStatus.Ready.name, MethodCallStatus.Failed.name])]
+        if not add_if_exists and self.has_persisted_data(filter_data=data, filter_compare_data=filter_compare_data):
+            return
+        
+        # Persist data
+        if use_index is None:
+            use_index = self.__get_use_next_index(use)
+        now_str = DateTime.datetime_2_str(DateTime.utcnow())
+        data.update({
+            'use_index': use_index,
+            'created_at': now_str,
+            'changed_at': now_str,
+            'status': MethodCallStatus.Ready.name,
+            'try_counter': 0,
+            'do_delete_on_success': self.__get_db_on_delete_after_when_add_method(delete_on_success, self.__delete_on_success),
+            'do_delete_on_fail': self.__get_db_on_delete_after_when_add_method(delete_on_fail, self.__delete_on_fail),
+            'do_delete_on_success_after_fail': self.__get_db_on_delete_after_when_add_method(delete_on_success_after_fail, self.__delete_on_success_after_fail)
+            })
+        
         self.add_persisted_data(data)
     
+    def get_number_of_functions_and_method_to_call(self, use=undefined_argument):
+        methods_data = self.__get_functions_and_methods_to_call(use=use)
+        return len(methods_data)
+    
+    def __get_db_on_delete_after_when_add_method(self, method_delete, default_delete):
+        if method_delete is not undefined_argument:
+            if method_delete is undefined_value:
+                return -1
+            else:
+                return method_delete
+        else:
+            if default_delete is undefined_value:
+                return -1
+            else:
+                return default_delete
+        
+    def __get_do_delete_after_call(self, db_delete, default_delete):
+        if db_delete != -1:
+            return db_delete
+        else:
+            if default_delete is undefined_value:
+                return False
+            else:
+                return default_delete
+        
     def __get_use_next_index(self, use):
-        datas = self.get_persisted_datas({'use':use})
+        datas = self.get_persisted_datas({'scope_name':self.__scope_name, 'use':use})
         if datas:
-            return max(map(lambda x:x['a'], datas)) + 1
+            return max(map(lambda x:x['use_index'], datas)) + 1
         else:
             return 0
     
-    def call_functions_and_methods(self, use="default", use_index=None, delete_after_call=False):
+    def __get_functions_and_methods_to_call(self, use=undefined_argument, use_index=None):
+        filter_data = {'scope_name':self.__scope_name}
+        if use is not undefined_argument:
+            filter_data['use'] = use
+            if use_index is not None:
+                filter_data['use_index'] = use_index
+        filter_compare_data = [('status', DBCompareOperator.In, [MethodCallStatus.Ready.name, MethodCallStatus.Failed.name])]
+        return self.get_persisted_datas(filter_data, filter_compare_data=filter_compare_data)
+    
+    def call_functions_and_methods(self, use="default", use_index=None):
         """Call methods of given use
         @param use: Define persistent usage. It usually corresponds to a specific scope.
         @param use_index: If defined, call only functions and methods of given index.
         @param delete_after_call: Define if function or method is deleted after call from persisted data.
         """
         # Get functions and methods to call
-        filter_data = {'use':use}
-        if use_index is not None:
-            filter_data['use_index'] = use_index
-        methods_data = self.get_persisted_datas(filter_data)
+        methods_data = self.__get_functions_and_methods_to_call(use=use)
         
         # Call methods
         if methods_data:
             for meth_index, meth_data in enumerate(methods_data):
-                do_delete = delete_after_call
+                status, do_delete, error = None, None, ''
                 try:
                     self._call_function_or_method(meth_data)
                 except Exception as exc:
-                    msg_list = [f"Error while calling following method (use: '{use}' ; use index: {use_index} ; method index: {meth_index} ; delete after call: {delete_after_call}):"]
+                    error = Tools.represent_exception(exc, indent=8)
+                    msg_list = [f"Error while calling following method (use: '{use}' ; use index: {use_index} ; method index: {meth_index}):"]
                     msg_list.append(Tools.represent_object(meth_data, 8))
                     msg_list.append("    Error:")
-                    msg_list.append(Tools.represent_exception(exc, indent=8))
+                    msg_list.append(error)
                     msg_list.append("  => Continue to process persisted methods")
                     msg_list.append("     WARNING: this method is removed from persisted methods to avoid recursive and blocking errors")
                     logger.error("\n".join(msg_list))
-                    do_delete = True
+                    status = MethodCallStatus.Failed
+                    do_delete = self.__get_do_delete_after_call(meth_data['do_delete_on_fail'], self.__delete_on_fail)
+                else:
+                    status = MethodCallStatus.Completed
+                    if meth_data['try_counter'] == 0:
+                        do_delete = self.__get_do_delete_after_call(meth_data['do_delete_on_success'], self.__delete_on_success)
+                    else:
+                        do_delete = self.__get_do_delete_after_call(meth_data['do_delete_on_success_after_fail'], self.__delete_on_success_after_fail)
+                
+                self.__update_persisted_data_after_call(do_delete, meth_data, status, error)
                 
-                if do_delete:
-                    self.__delete_function_or_method(meth_data)
+    def __update_persisted_data_after_call(self, do_delete, meth_data, status, error):
+        if do_delete:
+            self.__delete_function_or_method(meth_data)
+        else:
+            self.__update_function_or_method_status(meth_data, status, error)
     
     def __delete_function_or_method(self, function_or_method_data):
         filter_data = {'id':function_or_method_data['id']}
         self.delete_persisted_data(filter_data)
     
+    def __update_function_or_method_status(self, function_or_method_data, status, error):
+        filter_data = {'id':function_or_method_data['id']}
+        try_counter = function_or_method_data['try_counter'] + 1
+        if try_counter >= self.__expiration_try_counter and status == MethodCallStatus.Failed:
+            status = MethodCallStatus.Expired
+        
+        data = {
+            'status': status.name,
+            'try_counter': try_counter,
+            'error': error,
+            'changed_at': DateTime.datetime_2_str(DateTime.utcnow()),
+            }
+        self.update_persisted_data(data, filter_data=filter_data)
+    
     def _call_function_or_method(self, function_or_method_data):
         _, func = self.__expression_evaluator.evaluate_python_expression(function_or_method_data['function_qualname'])
         if not Typing.is_function(func):

holado_core/common/tools/path_manager.py

@@ -20,6 +20,7 @@ from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from datetime import datetime
 from holado_core.common.tools.tools import Tools
+from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
@@ -28,8 +29,15 @@ class PathManager(object):
 
     def __init__(self):
         pass
-
-    def makedirs(self, path, mode = None, is_directory = False, uid = None, gid = None):
+    
+    def get_user_group(self, path):
+        p = Path(path)
+        return p.owner(), p.group()
+    
+    def get_mode(self, path):
+        return os.stat(path).st_mode & 0o777
+    
+    def makedirs(self, path, mode = None, is_directory = False, user = None, group = None):
         if not is_directory:
             path = os.path.dirname(path)
         if not os.path.exists(path):
@@ -37,36 +45,48 @@ class PathManager(object):
                 os.makedirs(path, mode)
             else:
                 os.makedirs(path)
-            self.chown(path, uid, gid)
+            self.chown(path, user, group)
+            
+    def makefile(self, path, mode = None, user = None, group = None):
+        if not os.path.exists(path):
+            self.makedirs(path, mode, False, user, group)
+            open(path, 'a').close()
+            
+            if mode:
+                os.chmod(path, mode)
+            self.chown(path, user, group)
+            
+    def remove_path(self, path, ignore_errors=False):
+        if os.path.isfile(path):
+            try:
+                os.remove(path)
+            except Exception as exc:
+                if not ignore_errors:
+                    raise exc
+        elif os.path.isdir(path):
+            shutil.rmtree(path, ignore_errors=ignore_errors)
             
     def remove_paths(self, glob_pattern, ignore_errors=False):
         paths = glob(glob_pattern)
         for path in paths:
-            if os.path.isfile(path):
-                try:
-                    os.remove(path)
-                except Exception as exc:
-                    if not ignore_errors:
-                        raise exc
-            elif os.path.isdir(path):
-                shutil.rmtree(path, ignore_errors=ignore_errors)
+            self.remove_path(path, ignore_errors)
                 
-    def copy_path_recursively(self, src_path, dst_path, filter_patterns = None, ignore_patterns = None, do_log = False, log_prefix = "", uid = None, gid = None):
+    def copy_path_recursively(self, src_path, dst_path, filter_patterns = None, ignore_patterns = None, do_log = False, log_prefix = "", user = None, group = None):
     #         logging.debug("Copying path '{}' -> '{}' (ignoring {})".format(src_path, dst_path, ignore_patterns))
         # Copy path
         if os.path.isfile(src_path):
             if self.__filter_path(src_path, filter_patterns=filter_patterns, ignore_patterns=ignore_patterns, do_log=do_log, log_prefix=log_prefix):
                 if do_log:
                     logger.debug("{}Copy file '{}' -> '{}".format(log_prefix, src_path, dst_path))
-                self.makedirs(dst_path, uid=uid, gid=gid)
+                self.makedirs(dst_path, user=user, group=group)
                 shutil.copy2(src_path, dst_path)
-                self.chown(dst_path, uid, gid)
+                self.chown(dst_path, user, group)
         elif os.path.isdir(src_path):
             lp = os.listdir(src_path)
             for cp in lp:
                 cur_src_path = os.path.join(src_path, cp)
                 cur_dst_path = os.path.join(dst_path, cp)
-                self.copy_path_recursively(cur_src_path, cur_dst_path, filter_patterns=filter_patterns, ignore_patterns=ignore_patterns, do_log=do_log, log_prefix=log_prefix, uid=uid, gid=gid)
+                self.copy_path_recursively(cur_src_path, cur_dst_path, filter_patterns=filter_patterns, ignore_patterns=ignore_patterns, do_log=do_log, log_prefix=log_prefix, user=user, group=group)
     
     def __filter_paths(self, paths, filter_patterns = None, ignore_patterns = None, do_log = False, log_prefix = ""):
         if filter_patterns is not None and not isinstance(filter_patterns, list):
@@ -146,22 +166,23 @@ class PathManager(object):
         else:
             return os.path.join(base_path, "reports")
     
-    def chown(self, path, uid = None, gid = None):
-        if uid is not None or gid is not None:
-            if uid is None or gid is None:
-                raise TechnicalException(f"User and group ID cannot be None (uid={uid} ; gid={gid})")
-            os.chown(path, uid, gid)
+    def chown(self, path, user = None, group = None):
+        if user is not None or group is not None:
+            if user is None or group is None:
+                raise TechnicalException(f"User and group (name or ID) cannot be None (user={user} ; group={group})")
+            shutil.chown(path, user, group)
     
-    def check_file_exists(self, path, raise_exception=True):
+    def check_file_exists(self, path, do_exist=True, raise_exception=True):
         """
-         * @param path Path
-         * @param throwException If True, raises an exception rather than returning False
-         * @return True if given path is an existing file
+        @param path Path
+        @param do_exist Define to check if file exists or not
+        @param raise_exception If True, raises an exception rather than returning False
+        @return True if given path is an existing file
         """
-        res = os.path.exists(path)
+        res = (do_exist == os.path.exists(path))
         
         if not res and raise_exception:
-            raise FunctionalException(f"File '{path}' doesn't exist")
+            raise FunctionalException(f"File '{path}' " + "doesn't exist" if do_exist else "exists")
         return res
     
     def get_timestamped_path(self, prefix, ext, dt=None, dt_format="%Y%m%d-%H%M%S"):

holado_docker/tests/behave/steps/tools/docker_controller/client_steps.py

@@ -63,12 +63,13 @@ def step_impl(context, var_name, name, var_client):
     
     __get_variable_manager().register_variable(var_name, res)
 
-@Step(r"restart container (?P<name>{Str}) \(Docker Controller client: (?P<var_client>{Variable})\)")
-def step_impl(context, name, var_client):
+@Step(r"(?:(?P<or_start_str>start or ))?restart container (?P<name>{Str}) \(Docker Controller client: (?P<var_client>{Variable})\)")
+def step_impl(context, or_start_str, name, var_client):
+    or_start = or_start_str is not None
     name = StepTools.evaluate_scenario_parameter(name)
     client = StepTools.evaluate_variable_value(var_client)
     
-    client.restart_container(name)
+    client.restart_container(name, start_if_gone=or_start)
 
 @Step(r"start container (?P<name>{Str}) \(Docker Controller client: (?P<var_client>{Variable})\)")
 def step_impl(context, name, var_client):
@@ -77,18 +78,20 @@ def step_impl(context, name, var_client):
     
     client.start_container(name)
 
-@Step(r"stop container (?P<name>{Str}) \(Docker Controller client: (?P<var_client>{Variable})\)")
-def step_impl(context, name, var_client):
+@Step(r"stop container (?P<name>{Str})(?:(?P<if_started_str> if started))? \(Docker Controller client: (?P<var_client>{Variable})\)")
+def step_impl(context, name, if_started_str, var_client):
     name = StepTools.evaluate_scenario_parameter(name)
+    if_started = if_started_str is not None
     client = StepTools.evaluate_variable_value(var_client)
     
-    client.stop_container(name)
+    client.stop_container(name, raise_if_gone=not if_started)
 
-@Step(r"wait container (?P<name>{Str}) \(Docker Controller client: (?P<var_client>{Variable})\)")
-def step_impl(context, name, var_client):
+@Step(r"wait container (?P<name>{Str})(?:(?P<if_started_str> if started))? \(Docker Controller client: (?P<var_client>{Variable})\)")
+def step_impl(context, name, if_started_str, var_client):
     name = StepTools.evaluate_scenario_parameter(name)
+    if_started = if_started_str is not None
     client = StepTools.evaluate_variable_value(var_client)
     
-    client.wait_container(name)
+    client.wait_container(name, raise_if_gone=not if_started)
 
 

holado_docker/tools/docker_controller/client/rest/docker_controller_client.py

@@ -22,6 +22,21 @@ class DockerControllerClient(RestClient):
     def __init__(self, name, url, headers=None):
         super().__init__(name, url, headers)
     
+    # Common features
+    
+    def get_environment_variable_value(self, var_name):
+        data = [var_name]
+        response = self.get(f"os/env", data=data)
+        return self.response_result(response, status_ok=[200])
+    
+    def get_directory_filenames(self, path):
+        data = {'path':path}
+        response = self.get(f"os/ls", data=data)
+        return self.response_result(response, status_ok=[200])
+    
+    
+    # Manage containers
+    
     def get_containers_status(self, all_=False):
         if all_:
             response = self.get("container?all=true")
@@ -36,19 +51,52 @@ class DockerControllerClient(RestClient):
             response = self.get(f"container/{name}")
         return self.response_result(response, status_ok=[200,204])
     
-    def restart_container(self, name):
+    def restart_container(self, name, start_if_gone=False):
         response = self.put(f"container/{name}/restart")
-        return self.response_result(response, status_ok=[200,204])
+        if start_if_gone and response.status_code == 410:
+            return self.start_container(name)
+        else:
+            return self.response_result(response, status_ok=[200,204])
     
     def start_container(self, name):
         response = self.put(f"container/{name}/start")
         return self.response_result(response, status_ok=[200,204])
     
-    def stop_container(self, name):
+    def stop_container(self, name, raise_if_gone=True):
         response = self.put(f"container/{name}/stop")
-        return self.response_result(response, status_ok=[200,204])
+        if not raise_if_gone and response.status_code == 410:
+            return None
+        else:
+            return self.response_result(response, status_ok=[200,204])
     
-    def wait_container(self, name):
+    def wait_container(self, name, raise_if_gone=True):
         response = self.put(f"container/{name}/wait")
+        if not raise_if_gone and response.status_code == 410:
+            return None
+        else:
+            return self.response_result(response, status_ok=[200,204])
+    
+    
+    # Manage configuration
+    
+    def update_yaml_file(self, file_path, text, with_backup=True, backup_extension='.ha_bak'):
+        data = {
+            'file_path': file_path,
+            'yaml_string': text,
+            'with_backup': with_backup,
+            'backup_extension': backup_extension
+            }
+        response = self.patch(f"config/yaml_file", data=data)
         return self.response_result(response, status_ok=[200,204])
     
+    def restore_yaml_file(self, file_path, backup_extension='.ha_bak'):
+        data = {
+            'action': 'restore',
+            'file_path': file_path,
+            'backup_extension': backup_extension
+            }
+        response = self.put(f"config/yaml_file", data=data)
+        return self.response_result(response, status_ok=[200,204])
+    
+    
+    

holado_docker/tools/docker_controller/server/rest/api/config.py

@@ -0,0 +1,57 @@
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+from flask.views import MethodView
+from holado.common.context.session_context import SessionContext
+from holado_yaml.yaml.yaml_manager import YAMLManager
+
+def _get_session_context():
+    return SessionContext.instance()
+
+
+class YamlfileView(MethodView):
+    
+    def get(self, body: dict):
+        file_path = body['file_path']
+        
+        with open(file_path, 'rt') as fin:
+            res = fin.read()
+        
+        return res
+
+    def patch(self, body: dict):
+        file_path = body['file_path']
+        yaml_string = body['yaml_string']
+        with_backup = body['with_backup']
+        backup_extension = body['backup_extension']
+        
+        data = YAMLManager.load_string(yaml_string)
+        res = YAMLManager.update_file(file_path, data, with_backup=with_backup, backup_extension=backup_extension)
+        
+        return res
+
+    def put(self, body: list):
+        action = body['action']
+        file_path = body['file_path']
+        backup_extension = body['backup_extension']
+        
+        if action == 'restore':
+            res = YAMLManager.restore_file(file_path, backup_extension=backup_extension)
+        else:
+            return f"Unmanaged action '{action}'", 400
+            
+        return res
+
+
+
+
+

holado_docker/tools/docker_controller/server/rest/api/container.py

@@ -21,7 +21,7 @@ class RestartView(MethodView):
     
     def put(self, name, body: dict):
         if not _get_session_context().docker_client.has_container(name):
-            return f"Container '{name}' doesn't exist", 406
+            return f"Container '{name}' doesn't exist", 410
         
         res = _get_session_context().docker_client.restart_container(name, wait_running=False)
         return res
@@ -29,8 +29,8 @@ class RestartView(MethodView):
 class StartView(MethodView):
     
     def put(self, name, body: dict):
-        if not _get_session_context().docker_client.has_container(name):
-            return f"Container '{name}' doesn't exist", 406
+        if not _get_session_context().docker_client.has_container(name, all_=True):
+            return f"Container '{name}' doesn't exist", 410
         
         res = _get_session_context().docker_client.start_container(name, wait_running=False)
         return res
@@ -39,7 +39,7 @@ class StopView(MethodView):
     
     def put(self, name, body: dict):
         if not _get_session_context().docker_client.has_container(name):
-            return f"Container '{name}' doesn't exist", 406
+            return f"Container '{name}' doesn't exist", 410
         
         res = _get_session_context().docker_client.stop_container(name)
         return res
@@ -48,7 +48,7 @@ class WaitView(MethodView):
     
     def put(self, name, body: dict):
         if not _get_session_context().docker_client.has_container(name):
-            return f"Container '{name}' doesn't exist", 406
+            return f"Container '{name}' doesn't exist", 410
         
         res = _get_session_context().docker_client.get_container(name).wait()
         return res

holado_docker/tools/docker_controller/server/rest/api/os.py

@@ -0,0 +1,41 @@
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+from flask.views import MethodView
+from holado.common.context.session_context import SessionContext
+import os
+
+def _get_session_context():
+    return SessionContext.instance()
+
+
+class EnvView(MethodView):
+    
+    def get(self, body: list):
+        res = [os.getenv(name) for name in body]
+        return res
+
+
+class LsView(MethodView):
+    
+    def get(self, body: dict):
+        dir_path = body['path']
+        
+        res = []
+        for filename in os.listdir(dir_path):
+            if os.path.isfile(os.path.join(dir_path, filename)):
+                res.append(filename)
+        
+        return res
+
+
+