zscaler-sdk-python 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

zscaler/__init__.py

@@ -29,7 +29,7 @@ __license__ = "MIT"
 __contributors__ = [
     "William Guilherme",
 ]
-__version__ = "0.2.0"
+__version__ = "0.3.1"
 
 from zscaler.zia import ZIAClientHelper  # noqa
 from zscaler.zpa import ZPAClientHelper  # noqa

zscaler/cache/zscaler_cache.py

@@ -115,8 +115,8 @@ class ZscalerCache(Cache):
         """
         Clear the cache.
         """
+        logger.info("Clearing the entire cache.")
         self._store.clear()
-        logger.info("Cleared the cache.")
 
     def _clean_cache(self):
         """

zscaler/constants.py

@@ -9,8 +9,11 @@ ZPA_BASE_URLS = {
     "PREVIEW": "https://config.zpapreview.net",
     "QA": "https://config.qa.zpath.net",
     "QA2": "https://pdx2-zpa-config.qa2.zpath.net",
+    "DEV": "https://public-api.dev.zpath.net",
 }
 
+DEV_AUTH_URL = "https://authn1.dev.zpath.net/authn/v1/oauth/token"
+
 RETRYABLE_STATUS_CODES = {429, 500, 502, 503, 504}
 MAX_RETRIES = 5
 BACKOFF_FACTOR = 1

zscaler/zpa/__init__.py

@@ -11,7 +11,7 @@ from box import BoxList
 from zscaler import __version__
 from zscaler.cache.no_op_cache import NoOpCache
 from zscaler.cache.zscaler_cache import ZscalerCache
-from zscaler.constants import ZPA_BASE_URLS
+from zscaler.constants import ZPA_BASE_URLS, DEV_AUTH_URL
 from zscaler.errors.http_error import HTTPError, ZscalerAPIError
 from zscaler.exceptions.exceptions import HTTPException, ZscalerAPIException
 from zscaler.logger import setup_logging
@@ -117,6 +117,7 @@ class ZPAClientHelper(ZPAClient):
         self.v2_lss_url = f"{self.baseurl}/mgmtconfig/v2/admin/lssConfig/customers/{customer_id}"
         self.cbi_url = f"{self.baseurl}/cbiconfig/cbi/api/customers/{customer_id}"
         self.fail_safe = fail_safe
+
         # Cache setup
         cache_enabled = os.environ.get("ZSCALER_CLIENT_CACHE_ENABLED", "true").lower() == "true"
         if cache is None:
@@ -132,26 +133,27 @@ class ZPAClientHelper(ZPAClient):
         # Initialize user-agent
         ua = UserAgent()
         self.user_agent = ua.get_user_agent_string()
+        self.access_token = None
+        self.headers = {}
         self.refreshToken()
 
     def refreshToken(self):
-        # login
-        response = self.login()
-        if response is None or response.status_code > 299 or not response.json():
-            logger.error("Failed to login using provided credentials, response: %s", response)
-            raise Exception("Failed to login using provided credentials.")
-        self.access_token = response.json().get("access_token")
-        self.headers = {
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-            "Authorization": f"Bearer {self.access_token}",
-            "User-Agent": self.user_agent,
-        }
+        if not self.access_token or is_token_expired(self.access_token):
+            response = self.login()
+            if response is None or response.status_code > 299 or not response.json():
+                logger.error("Failed to login using provided credentials, response: %s", response)
+                raise Exception("Failed to login using provided credentials.")
+            self.access_token = response.json().get("access_token")
+            self.headers = {
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+                "Authorization": f"Bearer {self.access_token}",
+                "User-Agent": self.user_agent,
+            }
 
     @retry_with_backoff(retries=5)
     def login(self):
-        """Log in to the ZPA API and set the access token for subsequent requests."""
-        data = urllib.parse.urlencode({"client_id": self.client_id, "client_secret": self.client_secret})
+        params = {"client_id": self.client_id, "client_secret": self.client_secret}
         headers = {
             "Content-Type": "application/x-www-form-urlencoded",
             "Accept": "application/json",
@@ -159,8 +161,10 @@ class ZPAClientHelper(ZPAClient):
         }
         try:
             url = f"{self.baseurl}/signin"
+            if self.cloud == "DEV":
+                url = DEV_AUTH_URL + "?grant_type=CLIENT_CREDENTIALS"
+            data = urllib.parse.urlencode(params)
             resp = requests.post(url, data=data, headers=headers, timeout=self.timeout)
-            # Avoid logging all data from the response, focus on the status and a summary instead
             logger.info("Login attempt with status: %d", resp.status_code)
             return resp
         except Exception as e:
@@ -168,16 +172,6 @@ class ZPAClientHelper(ZPAClient):
             return None
 
     def send(self, method, path, json=None, params=None, api_version: str = None):
-        """
-        Send a request to the ZPA API.
-
-        Parameters:
-        - method (str): The HTTP method.
-        - path (str): API endpoint path.
-        - json (dict, optional): Request payload. Defaults to None.
-        Returns:
-        - Response: Response object from the request.
-        """
         api = self.url
         if api_version is None:
             api = self.url
@@ -192,13 +186,10 @@ class ZPAClientHelper(ZPAClient):
 
         url = f"{api}/{path.lstrip('/')}"
         start_time = time.time()
-        # Update headers to include the user agent
         headers_with_user_agent = self.headers.copy()
         headers_with_user_agent["User-Agent"] = self.user_agent
-        # Generate a unique UUID for this request
         request_uuid = uuid.uuid4()
         dump_request(logger, url, method, json, params, headers_with_user_agent, request_uuid)
-        # Check cache before sending request
         cache_key = self.cache.create_key(url, params)
         if method == "GET" and self.cache.contains(cache_key):
             resp = self.cache.get(cache_key)
@@ -215,12 +206,13 @@ class ZPAClientHelper(ZPAClient):
             return resp
 
         attempts = 0
-        while attempts < 5:  # Trying a maximum of 5 times
+        while attempts < 5:
             try:
-                # If the token is None or expired, fetch a new token
-                if is_token_expired(self.access_token):
-                    logger.warning("The provided or fetched token was already expired. Refreshing...")
-                    self.refreshToken()
+                self.refreshToken()
+                should_wait, delay = self.rate_limiter.wait(method)
+                if should_wait:
+                    logger.warning(f"Rate limit exceeded. Retrying in {delay} seconds.")
+                    time.sleep(delay)
                 resp = requests.request(
                     method,
                     url,
@@ -237,37 +229,39 @@ class ZPAClientHelper(ZPAClient):
                     request_uuid=request_uuid,
                     start_time=start_time,
                 )
-                if resp.status_code == 429:  # HTTP Status code 429 indicates "Too Many Requests"
-                    sleep_time = int(
-                        resp.headers.get("Retry-After", 2)
-                    )  # Default to 60 seconds if 'Retry-After' header is missing
-                    logger.warning(f"Rate limit exceeded. Retrying in {sleep_time} seconds.")
-                    sleep(sleep_time)
+                if resp.status_code == 429:
+                    retry_after = resp.headers.get("Retry-After")
+                    if retry_after:
+                        try:
+                            sleep_time = int(retry_after)
+                        except ValueError:
+                            sleep_time = int(retry_after[:-1])
+                        logger.warning(f"Rate limit exceeded. Retrying in {sleep_time} seconds.")
+                        time.sleep(sleep_time)
+                    else:
+                        time.sleep(60)
                     attempts += 1
                     continue
                 else:
                     break
             except requests.RequestException as e:
-                if attempts == 4:  # If it's the last attempt, raise the exception
+                if attempts == 4:
                     logger.error(f"Failed to send {method} request to {url} after 5 attempts. Error: {str(e)}")
                     raise e
                 else:
                     logger.warning(f"Failed to send {method} request to {url}. Retrying... Error: {str(e)}")
                     attempts += 1
-                    sleep(5)  # Sleep for 5 seconds before retrying
+                    time.sleep(5)
 
-        # If Non-GET call, clear the
         if method != "GET":
-            self.cache.delete(cache_key)
+            logger.info(f"Clearing cache for non-GET request: {method} {url}")
+            self.cache.clear()
 
-        # Detailed logging for request and response
         try:
             response_data = resp.json()
-        except ValueError:  # Using ValueError for JSON decoding errors
+        except ValueError:
             response_data = resp.text
-        # check if call was succesful
         if 200 > resp.status_code or resp.status_code > 299:
-            # create errors
             try:
                 error = ZscalerAPIError(url, resp, response_data)
                 if self.fail_safe:
@@ -280,7 +274,6 @@ class ZPAClientHelper(ZPAClient):
                     logger.error(response_data)
                     raise HTTPException(response_data)
             logger.error(error)
-        # Cache the response if it's a successful GET request
         if method == "GET" and resp.status_code == 200:
             self.cache.add(cache_key, resp)
         return resp
@@ -290,23 +283,34 @@ class ZPAClientHelper(ZPAClient):
         Send a GET request to the ZPA API.
 
         Parameters:
-        - path (str): API endpoint path.
-        - data (dict, optional): Request payload. Defaults to None.
+        path (str): API endpoint path.
+        json (dict, optional): Request payload. Defaults to None.
+        params (dict, optional): Query parameters. Defaults to None.
+        api_version (str, optional): API version to use. Defaults to None.
+
         Returns:
-        - Response: Response object from the request.
+        dict: Formatted JSON response from the API.
         """
-
-        # Use rate limiter before making a request
         should_wait, delay = self.rate_limiter.wait("GET")
         if should_wait:
             time.sleep(delay)
-
-        # Now proceed with sending the request
         resp = self.send("GET", path, json, params, api_version=api_version)
         formatted_resp = format_json_response(resp, box_attrs=dict())
         return formatted_resp
 
     def put(self, path, json=None, params=None, api_version: str = None):
+        """
+        Send a PUT request to the ZPA API.
+
+        Parameters:
+        path (str): API endpoint path.
+        json (dict, optional): Request payload. Defaults to None.
+        params (dict, optional): Query parameters. Defaults to None.
+        api_version (str, optional): API version to use. Defaults to None.
+
+        Returns:
+        dict: Formatted JSON response from the API.
+        """
         should_wait, delay = self.rate_limiter.wait("PUT")
         if should_wait:
             time.sleep(delay)
@@ -315,6 +319,18 @@ class ZPAClientHelper(ZPAClient):
         return formatted_resp
 
     def post(self, path, json=None, params=None, api_version: str = None):
+        """
+        Send a POST request to the ZPA API.
+
+        Parameters:
+        path (str): API endpoint path.
+        json (dict, optional): Request payload. Defaults to None.
+        params (dict, optional): Query parameters. Defaults to None.
+        api_version (str, optional): API version to use. Defaults to None.
+
+        Returns:
+        dict: Formatted JSON response from the API.
+        """
         should_wait, delay = self.rate_limiter.wait("POST")
         if should_wait:
             time.sleep(delay)
@@ -323,6 +339,18 @@ class ZPAClientHelper(ZPAClient):
         return formatted_resp
 
     def delete(self, path, json=None, params=None, api_version: str = None):
+        """
+        Send a DELETE request to the ZPA API.
+
+        Parameters:
+        path (str): API endpoint path.
+        json (dict, optional): Request payload. Defaults to None.
+        params (dict, optional): Query parameters. Defaults to None.
+        api_version (str, optional): API version to use. Defaults to None.
+
+        Returns:
+        Response: Response object from the DELETE request.
+        """
         should_wait, delay = self.rate_limiter.wait("DELETE")
         if should_wait:
             time.sleep(delay)

zscaler/zpa/app_segments.py

@@ -91,6 +91,41 @@ class ApplicationSegmentAPI:
                 return app
         return None
 
+    def get_segments_by_type(self, application_type: str, expand_all: bool = False, **kwargs) -> Box:
+        """
+        Retrieve all configured application segments of a specified type, optionally expanding all related data.
+
+        Args:
+            application_type (str): Type of application segment to retrieve.
+            Must be one of "BROWSER_ACCESS", "INSPECT", "SECURE_REMOTE_ACCESS".
+            expand_all (bool, optional): Whether to expand all related data. Defaults to False.
+
+        Keyword Args:
+            max_items (int, optional): The maximum number of items to request before stopping iteration.
+            max_pages (int, optional): The maximum number of pages to request before stopping iteration.
+            pagesize (int, optional): Specifies the page size. The default size is 20, but the maximum size is 500.
+            page (int, optional): Specifies the page number to begin fetching from.
+            search (str, optional): The search string used to match against features and fields.
+
+        Returns:
+            BoxList: List of application segments.
+
+        Examples:
+            >>> app_type = 'BROWSER_ACCESS'
+            >>> expand_all = True
+            >>> search = "ba_server01"
+            >>> app_segments = zpa.app_segments.get_segments_by_type(app_type, expand_all, search=search)
+        """
+        params = {"applicationType": application_type, "expandAll": "true" if expand_all else "false"}
+        # Include additional search parameters if specified
+        if "search" in kwargs:
+            params["search"] = kwargs["search"]
+
+        result, error = self.rest.get_paginated_data(path="/application/getAppsByType", params=params, **kwargs)
+        if error:
+            return BoxList([])  # Return an empty BoxList on failure due to the error
+        return result
+
     def delete_segment(self, segment_id: str, force_delete: bool = False) -> int:
         """
         Delete an application segment.