ibm-appconfiguration-python-sdk 0.3.8__tar.gz → 0.4.0__tar.gz

{ibm_appconfiguration_python_sdk-0.3.8/ibm_appconfiguration_python_sdk.egg-info → ibm_appconfiguration_python_sdk-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibm-appconfiguration-python-sdk
-Version: 0.3.8
+Version: 0.4.0
 Summary: IBM Cloud App Configuration Python SDK
 Home-page: https://github.com/IBM/appconfiguration-python-sdk
 Author: IBM
@@ -357,14 +357,6 @@ def configuration_update(self):
 appconfig_client.register_configuration_update_listener(configuration_update)
 ```
 
-## Fetch latest data
-
-Fetch the latest configuration data. 
-
-```py
-appconfig_client.fetch_configurations()
-```
-
 ## Enable debugger (Optional)
 
 Use this method to enable/disable the logging in SDK.

{ibm_appconfiguration_python_sdk-0.3.8 → ibm_appconfiguration_python_sdk-0.4.0}/README.md

@@ -321,14 +321,6 @@ def configuration_update(self):
 appconfig_client.register_configuration_update_listener(configuration_update)
 ```
 
-## Fetch latest data
-
-Fetch the latest configuration data. 
-
-```py
-appconfig_client.fetch_configurations()
-```
-
 ## Enable debugger (Optional)
 
 Use this method to enable/disable the logging in SDK.

{ibm_appconfiguration_python_sdk-0.3.8 → ibm_appconfiguration_python_sdk-0.4.0}/ibm_appconfiguration/appconfiguration.py

@@ -89,7 +89,6 @@ class AppConfiguration:
         self.__guid = ''
         self.__is_initialized = False
         self.__is_initialized_configuration = False
-        self.__is_loading = False
         AppConfiguration.__instance = self
 
     def use_private_endpoint(self, use_private_endpoint_param: bool):
@@ -131,7 +130,6 @@ class AppConfiguration:
         self.__region = region
         self.__guid = guid
         self.__is_initialized = True
-        self.__is_loading = False
         self.__setup_configuration_handler()
 
     def get_region(self) -> str:
@@ -216,14 +214,7 @@ class AppConfiguration:
         self.__is_initialized_configuration = True
 
         self.__configuration_handler_instance.set_context(collection_id, environment_id, default_options)
-        self.__load_data_now()
-
-    def fetch_configurations(self):
-        """Fetch the latest configurations"""
-        if self.__is_initialized and self.__is_initialized_configuration:
-            self.__load_data_now()
-        else:
-            Logger.error(config_messages.COLLECTION_INIT_ERROR)
+        self.__configuration_handler_instance.load_data()
 
     def __setup_configuration_handler(self):
         self.__configuration_handler_instance = ConfigurationHandler.get_instance()
@@ -231,13 +222,6 @@ class AppConfiguration:
                                                    override_service_url=self.__override_service_url,
                                                    use_private_endpoint=self.__use_private_endpoint)
 
-    def __load_data_now(self):
-        if self.__is_loading:
-            return
-        self.__is_loading = True
-        self.__configuration_handler_instance.load_data()
-        self.__is_loading = False
-
     def register_configuration_update_listener(self, listener):
         """Register a listener for the Configuration changes.
 

{ibm_appconfiguration_python_sdk-0.3.8 → ibm_appconfiguration_python_sdk-0.4.0}/ibm_appconfiguration/configurations/configuration_handler.py

@@ -15,11 +15,13 @@
 """
 Internal class to handle the configuration.
 """
+import json
 import os
 from typing import Dict, List, Any
 from threading import Timer, Thread
 from ibm_appconfiguration.configurations.internal.common import config_messages, config_constants
 from .internal.utils.logger import Logger
+from .internal.utils.parser import extract_configurations, format_config
 from .internal.utils.validators import Validators
 from .models import Feature
 from .models import SegmentRules
@@ -30,25 +32,13 @@ from .internal.utils.compute_percentage import get_normalized_value
 from .internal.utils.metering import Metering
 from .internal.utils.socket import Socket
 from .internal.utils.url_builder import URLBuilder
-from .internal.utils.connectivity import Connectivity
 from .internal.utils.api_manager import APIManager
-import sys
-from time import sleep
-
-# Server max time out is assumed to be 1 week = 604800 seconds = 40320*15
-sys.setrecursionlimit(40320)
-
-# delay between each web socket connection retry
-delay = 15
 
 
 class ConfigurationHandler:
     """Internal class to handle the configuration"""
     __instance = None
 
-    # variable to keep track of server-client connection status
-    __is_alive = False
-
     @staticmethod
     def get_instance():
         """ Static access method. """
@@ -80,8 +70,6 @@ class ConfigurationHandler:
         self.__on_socket_retry = False
         self.__override_service_url = None
         self.__socket = None
-        self.__connectivity = None
-        self.__is_network_connected = True
         self.__api_manager = None
         self.__use_private_endpoint = False
 
@@ -136,7 +124,6 @@ class ConfigurationHandler:
         self.__bootstrap_file = options['bootstrap_file']
         self.__persistent_cache_dir = options['persistent_cache_dir']
         self.__is_initialized = True
-        self.__check_network()
 
     def load_data(self):
         """Load the configuration data"""
@@ -147,7 +134,9 @@ class ConfigurationHandler:
             self.__persistent_data = FileManager.read_files(
                 file_path=os.path.join(self.__persistent_cache_dir, 'appconfiguration.json'))
             if self.__persistent_data is not None:
-                self.__load_configurations(self.__persistent_data)
+                self.__load_configurations(
+                    extract_configurations(self.__persistent_data, self.__environment_id, self.__collection_id)
+                )
             if not os.access(self.__persistent_cache_dir, os.W_OK):
                 Logger.error(config_messages.ERROR_NO_WRITE_PERMISSION)
                 return
@@ -156,11 +145,13 @@ class ConfigurationHandler:
                 if self.__persistent_data is None or len(self.__persistent_data) == 0:
                     bootstrap_file_data = FileManager.read_files(file_path=self.__bootstrap_file)
                     if bootstrap_file_data is not None:
-                        self.__load_configurations(bootstrap_file_data)
+                        configurations = extract_configurations(bootstrap_file_data, self.__environment_id, self.__collection_id)
+                        self.__load_configurations(configurations)
+                        self.__write_to_persistent_storage(format_config(configurations, self.__environment_id, self.__collection_id),
+                            self.__persistent_cache_dir)
                     else:
                         Logger.error("Error reading bootstrap file data")
                         return
-                    self.__write_to_persistent_storage(bootstrap_file_data, self.__persistent_cache_dir)
                     if self.__configuration_update_listener and callable(self.__configuration_update_listener):
                         self.__configuration_update_listener()
                 else:
@@ -169,7 +160,9 @@ class ConfigurationHandler:
             else:
                 bootstrap_file_data = FileManager.read_files(file_path=self.__bootstrap_file)
                 if bootstrap_file_data is not None:
-                    self.__load_configurations(bootstrap_file_data)
+                    self.__load_configurations(
+                        extract_configurations(bootstrap_file_data, self.__environment_id, self.__collection_id)
+                    )
                 else:
                     Logger.error("Error reading bootstrap file data")
                     return
@@ -193,28 +186,6 @@ class ConfigurationHandler:
         else:
             Logger.error(config_messages.CONFIGURATION_HANDLER_METHOD_ERROR)
 
-    def __check_network(self):
-        if self.__live_config_update_enabled:
-            if self.__connectivity is None:
-                self.__connectivity = Connectivity.get_instance()
-                self.__connectivity.add_connectivity_listener(self.__network_listener)
-                self.__connectivity.check_connection()
-        else:
-            self.__connectivity = None
-
-    def __network_listener(self, is_connected: bool):
-        if not self.__live_config_update_enabled:
-            self.__connectivity = None
-            return
-
-        if is_connected:
-            if not self.__is_network_connected:
-                self.__is_network_connected = True
-                self.__fetch_config_data()
-        else:
-            Logger.debug(config_messages.NO_INTERNET_CONNECTION_ERROR)
-            self.__is_network_connected = False
-
     def get_properties(self) -> Dict[str, Property]:
         """Get the list of Property objects
 
@@ -263,24 +234,15 @@ class ConfigurationHandler:
         if self.__is_initialized:
             self.__fetch_from_api()
             self.__on_socket_retry = False
-            # Socket connection is a long-running background task, and is safe to run as daemon threads
-            config_thread = Thread(target=self.__start_web_socket, args=())
-            config_thread.daemon = True
-            config_thread.start()
+            self.__start_web_socket()
 
     def __start_web_socket(self):
-        bearer_token = URLBuilder.get_iam_authenticator().token_manager.get_token()
-        headers = {
-            'Authorization': 'Bearer ' + bearer_token
-        }
-        if self.__socket:
-            self.__socket.cancel()
-            self.__socket = None
+
         self.__socket = Socket()
         self.__socket.setup(
             url=URLBuilder.get_web_socket_url(),
-            headers=headers,
-            callback=self.__on_web_socket_callback
+            headers_provider=self.__api_manager.get_websocket_headers,
+            callback=self.__handle_socket_events
         )
 
     def __load_configurations(self, data: dict):
@@ -478,8 +440,8 @@ class ConfigurationHandler:
                 Logger.debug(err)
         return rule_map
 
-    def __write_to_persistent_storage(self, json: dict, file_path: str):
-        FileManager.store_files(json, os.path.join(file_path, 'appconfiguration.json'))
+    def __write_to_persistent_storage(self, data: str, file_path: str):
+        FileManager.store_files(json.dumps(json.loads(data), indent=2), os.path.join(file_path, 'appconfiguration.json'))
 
     def __fetch_from_api(self):
         if self.__is_initialized:
@@ -506,8 +468,8 @@ class ConfigurationHandler:
                 Logger.info(config_messages.CONFIGURATIONS_FETCH_SUCCESS)
                 response_data = response.get_result()
                 try:
-                    response_data = dict(response_data)
-                    self.__load_configurations(response_data)  # load response to cache maps
+                    configurations = extract_configurations(json.dumps(response_data), self.__environment_id, self.__collection_id)
+                    self.__load_configurations(configurations)  # load response to cache maps
                     if self.__configuration_update_listener and callable(self.__configuration_update_listener):
                         self.__configuration_update_listener()
                     # we have already loaded the configurations to feature & property dicts.
@@ -515,7 +477,7 @@ class ConfigurationHandler:
                     # But the thread shouldn't be a daemon thread, because the writing should complete even if the main thread has terminated.
                     if self.__persistent_cache_dir:
                         file_write_thread = Thread(target=self.__write_to_persistent_storage,
-                                                   args=(response_data, self.__persistent_cache_dir,))
+                            args=(format_config(configurations, self.__environment_id, self.__collection_id), self.__persistent_cache_dir))
                         file_write_thread.start()
                 except Exception as exception:
                     Logger.error(f'error while while fetching {exception}')
@@ -538,32 +500,20 @@ class ConfigurationHandler:
         else:
             Logger.debug(config_messages.CONFIGURATION_HANDLER_INIT_ERROR)
 
-    def __on_web_socket_callback(self, message=None, error_state=None,
-                                 closed_state=None, open_state=None):
+    def __handle_socket_events(self, message=None, error_state=None,
+                               closed_state=None, open_state=None):
         if message:
-            self.__is_alive = True
+            Logger.debug(f'Received message from websocket. {message}')
             self.__fetch_from_api()
-            Logger.debug(f'Received message from socket. {message}')
         elif error_state:
-            self.__is_alive = False
-            Logger.error(f'Received error from socket. {error_state}')
-            Logger.info('Reconnecting to server....')
             self.__on_socket_retry = True
-            sleep(delay)
-            self.__start_web_socket()
         elif closed_state:
-            self.__is_alive = False
-            Logger.error('Received close connection from socket.')
-            Logger.info('Reconnecting to server....')
             self.__on_socket_retry = True
-            sleep(delay)
-            self.__start_web_socket()
         elif open_state:
-            self.__is_alive = True
+            Logger.debug('Received opened connection from websocket.')
             if self.__on_socket_retry:
                 self.__on_socket_retry = False
                 self.__fetch_from_api()
-            Logger.debug('Received opened connection from socket.')
         else:
             Logger.error('Unknown Error inside the socket connection.')
 
@@ -572,4 +522,4 @@ class ConfigurationHandler:
 
         Returns: boolean indicating connection status
         """
-        return self.__is_alive
+        return self.__socket.is_connected()

{ibm_appconfiguration_python_sdk-0.3.8 → ibm_appconfiguration_python_sdk-0.4.0}/ibm_appconfiguration/configurations/internal/common/config_constants.py

@@ -24,3 +24,5 @@ MAX_NUMBER_OF_RETRIES = 3
 DEFAULT_ROLLOUT_PERCENTAGE = '$default'
 DEFAULT_FEATURE_VALUE = '$default'
 DEFAULT_PROPERTY_VALUE = '$default'
+WEBSOCKET_RECONNECT_DELAY = 15  # Constant delay between reconnection attempts for server errors
+CUSTOM_SOCKET_CLOSE_REASON_CODE = 4001

{ibm_appconfiguration_python_sdk-0.3.8 → ibm_appconfiguration_python_sdk-0.4.0}/ibm_appconfiguration/configurations/internal/common/config_messages.py

@@ -35,7 +35,6 @@ CONFIGURATION_HANDLER_INIT_ERROR = 'Invalid action in ConfigurationHandler. This
 CONFIGURATION_HANDLER_METHOD_ERROR = "Invalid action in ConfigurationHandler. Should be a method/function"
 SINGLETON_EXCEPTION = "class must be initialized using the get_instance() method."
 FEATURE_INVALID = "Invalid feature_id - "
-NO_INTERNET_CONNECTION_ERROR = 'No connection to internet. Please re-connect.'
 PROPERTY_INVALID = "Invalid property_id - "
 CONFIGURATIONS_FETCH_SUCCESS = "Successfully fetched the configurations."
 RETRY_AFTER_TWO_MINUTES = "Failed to fetch the configurations. Retrying after 2 minutes."

{ibm_appconfiguration_python_sdk-0.3.8 → ibm_appconfiguration_python_sdk-0.4.0}/ibm_appconfiguration/configurations/internal/utils/api_manager.py

@@ -19,6 +19,8 @@ import json as json_import
 from typing import Optional, Union
 from ibm_cloud_sdk_core import BaseService, DetailedResponse, ApiException
 from requests.exceptions import RetryError
+
+from .logger import Logger
 from .url_builder import URLBuilder
 from ibm_appconfiguration.version import __version__
 from ..common import config_constants
@@ -99,3 +101,26 @@ class APIManager(BaseService):
         if isinstance(dictionary, dict):
             return {k: v for (k, v) in dictionary.items() if v is not None}
         return dictionary
+
+    def get_websocket_headers(self) -> dict:
+        """Get fresh headers for WebSocket connection with current authentication token.
+        This method retrieves a fresh authentication token and returns headers
+        suitable for WebSocket connections. It should be called each time a
+        WebSocket connection is established to ensure the token is valid.
+
+        Returns:
+            dict: Headers dictionary containing Authorization and User-Agent
+
+        Raises:
+            Exception: If token retrieval fails, the exception is propagated
+                      to allow the caller to determine if reconnection should be attempted
+        """
+        try:
+            bearer_token = URLBuilder.get_iam_authenticator().token_manager.get_token()
+            return {
+                'Authorization': 'Bearer ' + bearer_token,
+                'User-Agent': '{0}/{1}'.format(config_constants.SDK_NAME, __version__)
+            }
+        except Exception as e:
+            Logger.error(f"Failed to retrieve IAM token for WebSocket: {str(e)}")
+            raise

{ibm_appconfiguration_python_sdk-0.3.8 → ibm_appconfiguration_python_sdk-0.4.0}/ibm_appconfiguration/configurations/internal/utils/file_manager.py

@@ -18,8 +18,7 @@ file based cache of the SDK.
 """
 
 import fcntl
-import json
-from typing import Optional, Any
+from typing import Optional
 
 from .logger import Logger
 
@@ -28,17 +27,17 @@ class FileManager:
     """FileManager to handle the cache"""
 
     @classmethod
-    def store_files(cls, json_data: {}, file_path: str) -> bool:
+    def store_files(cls, data: str, file_path: str) -> bool:
         """Store the file
 
         Args:
-            json_data: Data to be stored.
+            data: Data to be stored.
             file_path: File path for the cache.
         """
         try:
             with open(file_path, 'w') as cache:
                 fcntl.flock(cache, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                json.dump(json_data, cache)
+                cache.write(data)
                 fcntl.flock(cache, fcntl.LOCK_UN)
                 return True
         except Exception as err:
@@ -46,7 +45,7 @@ class FileManager:
             return False
 
     @classmethod
-    def read_files(cls, file_path: str) -> Optional[Any]:
+    def read_files(cls, file_path: str) -> Optional[str]:
         """
         Read the data from the given path.
 
@@ -59,9 +58,9 @@ class FileManager:
         try:
             with open(file_path, 'r') as file:
                 fcntl.flock(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                data = json.load(file)
+                data = file.read()
                 fcntl.flock(file, fcntl.LOCK_UN)
-                return data
+                return data if len(data) > 0 else None
         except Exception as err:
             Logger.error(err)
             return None

ibm_appconfiguration_python_sdk-0.4.0/ibm_appconfiguration/configurations/internal/utils/parser.py

@@ -0,0 +1,149 @@
+import json
+from typing import Any, Dict, List, Set
+
+
+def extract_environment_data(data: Dict[str, Any], environment_id: str) -> Dict[str, Any]:
+    """
+    Prepares config data for extraction with validation.
+
+    :param data: The full JSON configuration as a dictionary.
+    :param environment_id: The environment ID to extract.
+    :return: A dictionary containing 'features', 'properties', and 'segments'.
+    :raises: Exception if the format is invalid or environment not found.
+    """
+    if not isinstance(data.get("segments"), list) or not isinstance(data.get("environments"), list):
+        raise Exception("Improper Data format present in configuration")
+
+    for environment in data["environments"]:
+        if environment.get("environment_id") == environment_id:
+            return {
+                "features": environment.get("features", []),
+                "properties": environment.get("properties", []),
+                "segments": data["segments"]
+            }
+
+    raise Exception("Matching environment not found in configuration")
+
+
+def validate_resource(resource: Dict[str, Any], collection: str) -> bool:
+    """
+    Validates if the feature/property belongs to the given collection.
+
+    :param resource: The feature or property dictionary.
+    :param collection: The collection ID to match.
+    :return: True if valid, False otherwise.
+    :raises: Exception if collection format is invalid.
+    """
+    if "collections" not in resource:
+        return True
+
+    collections = resource["collections"]
+    if not isinstance(collections, list):
+        raise Exception("Improper collection format in resource data")
+
+    for col in collections:
+        if col.get("collection_id") == collection:
+            return True
+
+    return False
+
+
+def append_segment_ids(resource: Dict[str, Any], segment_ids: Set[str]):
+    """
+    Appends segment IDs from the resource's segment rules into the given set.
+
+    :param resource: The feature or property dictionary.
+    :param segment_ids: A set to accumulate segment IDs.
+    """
+    for segment_rule in resource.get("segment_rules", []):
+        for rule in segment_rule.get("rules", []):
+            for segment_id in rule.get("segments", []):
+                segment_ids.add(segment_id)
+
+
+def extract_resources(resource_data: Dict[str, Any], collection: str) -> Dict[str, List[Any]]:
+    """
+    Extracts features, properties, and segments after validation.
+
+    :param resource_data: The environment-specific data.
+    :param collection: The collection ID to validate against.
+    :return: A dictionary with keys 'features', 'properties', and 'segments'.
+    :raises: Exception if any required segment is missing.
+    """
+    features = []
+    properties = []
+    segments = []
+    required_segment_ids = set()
+
+    for feature in resource_data.get("features", []):
+        if validate_resource(feature, collection):
+            append_segment_ids(feature, required_segment_ids)
+            features.append(feature)
+
+    for property_ in resource_data.get("properties", []):
+        if validate_resource(property_, collection):
+            append_segment_ids(property_, required_segment_ids)
+            properties.append(property_)
+
+    available_segments = resource_data.get("segments", [])
+    for segment in available_segments:
+        if segment.get("segment_id") in required_segment_ids:
+            segments.append(segment)
+            required_segment_ids.remove(segment.get("segment_id"))
+
+    if len(required_segment_ids) > 0:
+        raise Exception(f"Required segment doesn't exist in provided segments")
+
+    return {
+        "features": features,
+        "properties": properties,
+        "segments": segments
+    }
+
+
+def extract_configurations(data: str, environment: str, collection: str) -> Dict[str, List[Any]]:
+    """
+    Unified parser for app-config data for new SDK/export/promote format.
+
+    :param data: Raw JSON string of the config.
+    :param environment: The environment ID.
+    :param collection: The collection ID.
+    :return: A dictionary with 'features', 'properties', and 'segments'.
+    :raises: Exception on any validation or format error.
+    """
+    try:
+        configurations = json.loads(data)
+
+        if "collections" not in configurations or not isinstance(configurations["collections"], list):
+            raise Exception("Improper/Missing collections in configuration")
+
+        if not any(col.get("collection_id") == collection for col in configurations["collections"]):
+            raise Exception("Required collection not found in collections")
+
+        config_data = extract_environment_data(configurations, environment)
+        return extract_resources(config_data, collection)
+
+    except Exception as e:
+        raise Exception(f"Extraction of configurations failed with error:\n {str(e)}")
+
+
+def format_config(res: Dict[str, List[Any]], environment_id: str, collection_id: str) -> str:
+    """
+    Formats the extracted resources into unified config format.
+
+    :param res: The extracted config (from `extract_configurations`).
+    :param environment_id: The environment ID to include.
+    :param collection_id: The collection ID to include.
+    :return: A formatted configuration dictionary.
+    """
+    return json.dumps({
+        "environments": [
+            {
+                "environment_id": environment_id,
+                "features": res.get("features", []),
+                "properties": res.get("properties", [])
+            }
+        ],
+        "collections": [{"collection_id": collection_id}],
+        "segments": res.get("segments", [])
+    })