updated logic

Author: kleinjoshuaa

CHANGES.txt

@@ -39,5 +39,5 @@
 - Updated keyId of an API KEY to be the actual ID and not the key itself
 3.2.0 (Feb 2, 2025)
 - Updated to support flag sets, large segments and the impressionsDisabled boolean value
-3.5.0 (Mar 14, 2025)
+3.5.0 (May 6, 2025)
 - Updated to support harness mode

README.md

@@ -20,25 +20,27 @@ from splitapiclient.main import get_client
 client = get_client({'apikey': 'ADMIN API KEY'})
 ```
 
-### Harness Mode
+## Using in Harness Mode
 
-Split has been acquired by Harness. This client now supports a 'harness_mode' which uses a different authentication mechanism and provides access to Harness-specific resources.
+Starting with version 3.5.0, the Split API client supports operating in "harness mode" to interact with both Split and Harness Feature Flags APIs.
 
-#### Authentication
+For detailed information about Harness Feature Flags API endpoints, please refer to the [official Harness API documentation](https://apidocs.harness.io/).
 
-In harness mode, authentication can be configured in two ways:
-- Use `harness_token` for Harness endpoints and `apikey` for Split endpoints
-- If `harness_token` is not provided, `apikey` will be used for all operations
+### Authentication in Harness Mode
 
-Harness endpoints use the 'x-api-key' header instead of the standard Split authentication.
+The client supports multiple authentication scenarios:
 
-#### Base URLs and Endpoints
+1. Harness-specific endpoints always use the 'x-api-key' header format
+2. Split endpoints will use the 'x-api-key' header when using the harness_token
+3. Split endpoints will use the normal 'Authorization' header when using the apikey
+4. If both harness_token and apikey are provided, the client will use the harness_token for Harness endpoints and the apikey for Split endpoints
+
+### Base URLs and Endpoints
 
 - Existing, non-deprecated Split endpoints continue to use the Split base URLs
 - New Harness-specific endpoints use the Harness base URL (https://app.harness.io/)
-- There is no v3 version for the Harness API
 
-#### Deprecated Endpoints
+### Deprecated Endpoints
 
 The following endpoints are deprecated and cannot be used in harness mode:
 - `/workspaces`: POST, PATCH, DELETE, PUT verbs are deprecated
@@ -47,7 +49,7 @@ The following endpoints are deprecated and cannot be used in harness mode:
 - `/groups`: all verbs are deprecated
 - `/restrictions`: all verbs are deprecated
 
-#### Basic Usage
+### Basic Usage
 
 To use the client in harness mode:
 
@@ -58,17 +60,20 @@ from splitapiclient.main import get_client
 client = get_client({
     'harness_mode': True,
     'harness_token': 'YOUR_HARNESS_TOKEN',  # Used for Harness-specific endpoints
-    'apikey': 'YOUR_SPLIT_API_KEY'         # Used for existing Split endpoints
+    'apikey': 'YOUR_SPLIT_API_KEY',         # Used for existing Split endpoints
+    'account_identifier': 'YOUR_HARNESS_ACCOUNT_ID'  # Required for Harness operations
 })
 
-# Option 2: Use apikey for all operations (if harness_token is not provided)
+# Option 2: Use harness_token for all operations (if apikey is not provided)
 client = get_client({
     'harness_mode': True,
-    'apikey': 'YOUR_API_KEY'  # Used for both Split and Harness endpoints
+    'harness_token': 'YOUR_HARNESS_TOKEN',  # Used for both Harness and Split endpoints
+    'account_identifier': 'YOUR_HARNESS_ACCOUNT_ID'
 })
+
 ```
 
-#### Working with Split Resources in Harness Mode
+### Working with Split Resources in Harness Mode
 
 You can still access standard Split resources with some restrictions:
 
@@ -83,113 +88,58 @@ ws = client.workspaces.find("Default")
 # List environments in a workspace
 for env in client.environments.list(ws.id):
     print(f"Environment: {env.name}, Id: {env.id}")
-
-# List splits in a workspace
-for split in client.splits.list(ws.id):
-    print(f"Split: {split.name}")
 ```
 
-#### Working with Harness-specific Resources
+### Working with Harness-specific Resources
+
+Harness mode provides access to several Harness-specific resources through dedicated microclients:
+
+- token
+- harness_apikey
+- service_account
+- harness_user
+- harness_group
+- role
+- resource_group
+- role_assignment
+- harness_project
 
-Harness mode provides access to several Harness-specific resources:
+Basic example:
 
 ```python
-# Account identifier is required for Harness operations
+# Account identifier is required for all Harness operations
 account_id = 'YOUR_ACCOUNT_IDENTIFIER'
 
-# List tokens
-for token in client.token.list(account_id):
+# List all tokens
+tokens = client.token.list(account_id)
+for token in tokens:
     print(f"Token: {token.name}, ID: {token.id}")
 
-# Get a specific token
-token = client.token.get('TOKEN_ID', account_id)
-
-# List Harness API keys
-for api_key in client.harness_apikey.list(api_key_type="STANDARD", account_identifier=account_id):
-    print(f"API Key: {api_key.name}, ID: {api_key.id}")
-
 # List service accounts
-for sa in client.service_account.list(account_id):
+service_accounts = client.service_account.list(account_id)
+for sa in service_accounts:
     print(f"Service Account: {sa.name}, ID: {sa.id}")
-
-# List Harness users
-for user in client.harness_user.list(account_id):
-    print(f"User: {user.name}, Email: {user.email}")
-
-# List Harness groups
-for group in client.harness_group.list(account_id):
-    print(f"Group: {group.name}, ID: {group.id}")
-
-# List roles
-for role in client.role.list(account_id):
-    print(f"Role: {role.name}, ID: {role.id}")
-
-# List resource groups
-for rg in client.resource_group.list(account_id):
-    print(f"Resource Group: {rg.name}, ID: {rg.id}")
-
-# List role assignments
-for ra in client.role_assignment.list(account_id):
-    print(f"Role Assignment: {ra.id}, Role: {ra.role_identifier}")
-
-# List Harness projects
-for project in client.harness_project.list(account_identifier=account_id):
-    print(f"Project: {project.name}, ID: {project.identifier}")
-
-# Get a specific project
-project = client.harness_project.get('PROJECT_ID', account_identifier=account_id)
 ```
 
-#### Account Identifier
+For detailed examples and API specifications for each resource, please refer to the [Harness API documentation](https://apidocs.harness.io/).
 
-The `account_identifier` is a required parameter for all Harness operations. You have two options for providing it:
+### Setting Default Account Identifier
 
-1. Specify it during client initialization (recommended):
+To avoid specifying the account identifier with every request:
 
 ```python
-from splitapiclient.main import get_client
-
-# Specify account_identifier during initialization
+# Set default account identifier when creating the client
 client = get_client({
     'harness_mode': True,
-    'harness_token': 'YOUR_HARNESS_TOKEN', 
-    'apikey': 'YOUR_SPLIT_API_KEY',
-    'account_identifier': 'YOUR_ACCOUNT_ID'  # Will be used for all Harness operations
+    'harness_token': 'YOUR_HARNESS_TOKEN',
+    'account_identifier': 'YOUR_ACCOUNT_IDENTIFIER'
 })
 
 # Now you can make calls without specifying account_identifier in each request
 tokens = client.token.list()  # account_identifier is automatically included
 projects = client.harness_project.list()  # account_identifier is automatically included
 ```
 
-2. Provide it with each API call:
-
-```python
-from splitapiclient.main import get_client
-
-# Initialize without account_identifier
-client = get_client({
-    'harness_mode': True,
-    'harness_token': 'YOUR_HARNESS_TOKEN',
-    'apikey': 'YOUR_SPLIT_API_KEY'
-})
-
-# Must specify account_identifier with each API call
-tokens = client.token.list(account_identifier='YOUR_ACCOUNT_ID')
-projects = client.harness_project.list(account_identifier='YOUR_ACCOUNT_ID')
-```
-
-If you don't provide the account_identifier either during initialization or with each API call, the client will raise a ValueError when you try to access Harness resources.
-
-You can still override the account_identifier for specific calls even if you provided it during initialization:
-
-```python
-# Override the default account_identifier for a specific call
-other_account_projects = client.harness_project.list(account_identifier='DIFFERENT_ACCOUNT_ID')
-```
-
-The account identifier can be found in your Harness account settings or through the Harness UI. It is typically in the format of a unique string identifying your organization in the Harness platform.
-
 ### Testing API Endpoints
 
 #### Example: Creating and Managing Split Resources

splitapiclient/http_clients/harness_client.py

@@ -8,7 +8,7 @@
 from splitapiclient.util.logger import LOGGER
 from splitapiclient.util.exceptions import HTTPResponseError, \
     HTTPNotFoundError, HTTPIncorrectParametersError, HTTPUnauthorizedError, \
-    SplitBackendUnreachableError, HarnessDeprecatedEndpointError
+    SplitBackendUnreachableError, HarnessDeprecatedEndpointError, MissingParametersException
 
 
 class HarnessHttpClient(base_client.BaseHttpClient):
@@ -36,11 +36,13 @@ def __init__(self, baseurl, auth_token):
         :param baseurl: string. Harness host and base url.
         :param auth_token: string. Harness authentication token needed to make API calls.
         '''
-        super(HarnessHttpClient, self).__init__(baseurl, auth_token)
-        # Override the authorization header to use x-api-key
-        self.config['base_args'] = {
-            'x-api-key': auth_token
+        # Initialize with empty base_args - we'll handle auth differently in harness mode
+        self.config = {
+            'base_url': baseurl,
+            'base_args': {}
         }
+        # Store the auth token
+        self._auth_token = auth_token
 
     def setup_method(self, method, body=None):
         '''
@@ -97,6 +99,18 @@ def _is_deprecated_endpoint(self, endpoint, body=None):
 
         return False
 
+    def _is_harness_endpoint(self, endpoint):
+        '''
+        Determines if the endpoint is a Harness-specific endpoint based on the base URL.
+        
+        :param endpoint: dict. Endpoint description.
+        :return: bool. True if the endpoint is a Harness endpoint, False otherwise.
+        '''
+        # In the harness client, we can determine if it's a Harness endpoint by checking the base URL
+        # Split API base URLs are typically api.split.io
+        # Harness API base URLs are typically app.harness.io
+        return 'app.harness.io' in self.config['base_url']
+
     def _handle_invalid_response(self, response):
         '''
         Handle responses that are not okay and throw an appropriate exception.
@@ -128,6 +142,77 @@ def _handle_connection_error(self, e):
         raise SplitBackendUnreachableError(
             'Unable to reach Harness backend'
         )
+        
+    @staticmethod
+    def validate_params(endpoint, all_arguments):
+        '''
+        Override the base client validation to handle harness mode authentication.
+        In harness mode, we use x-api-key instead of Authorization, so we need to
+        modify the validation logic to not require the Authorization header.
+        
+        :param endpoint: dict. Endpoint description
+        :param all_arguments: Parameter values
+        
+        :rtype: None
+        '''
+        # Get required parameters from URL template and query string
+        url_params = base_client.BaseHttpClient.get_params_from_url_template(endpoint['url_template'])
+        query_params = [i['name'] for i in endpoint['query_string'] if i['required']]
+        
+        # Add required headers, but exclude 'Authorization' since we're using 'x-api-key' in harness mode
+        header_params = []
+        for header in endpoint['headers']:
+            if header['required'] and header['name'] != 'Authorization':
+                header_params.append(header['name'])
+        
+        # Combine all required parameters
+        required_params = url_params + header_params + query_params
+        
+        # Check if any required parameters are missing
+        missing = [p for p in required_params if p not in all_arguments]
+        
+        if missing:
+            raise MissingParametersException(
+                'The following required parameters are missing: {missing}'
+                .format(missing=', '.join(missing))
+            )
+
+    def _setup_headers(self, endpoint, params):
+        '''
+        Override the base client _setup_headers method to handle harness mode authentication.
+        In harness mode, we need to skip 'Authorization' headers and use 'x-api-key' instead.
+        
+        :param endpoint: dict. Endpoint description
+        :param params: dict. List of parameter values
+        
+        :rtype: dict.
+        '''
+        # Set up required headers except 'Authorization'
+        headers = {}
+        for header in endpoint['headers']:
+            if header.get('required', False):
+                # Skip 'Authorization' header in harness mode
+                if header['name'] == 'Authorization':
+                    continue
+                if header['name'] in params:
+                    headers[header['name']] = base_client.BaseHttpClient._process_single_header(
+                        header, params[header['name']]
+                    )
+        
+        # Add optional headers
+        headers.update({
+            header['name']: base_client.BaseHttpClient._process_single_header(
+                header, params[header['name']]
+            )
+            for header in endpoint['headers']
+            if (not header.get('required', False)) and header['name'] in params
+        })
+        
+        # Add x-api-key header
+        if 'x-api-key' in params:
+            headers['x-api-key'] = params['x-api-key']
+        
+        return headers
 
     def make_request(self, endpoint, body=None, **kwargs):
         '''
@@ -148,6 +233,9 @@ def make_request(self, endpoint, body=None, **kwargs):
                 f"Endpoint {endpoint['url_template']} with method {endpoint['method']} is deprecated in harness mode"
             )
 
+        # In harness mode, use x-api-key header for all endpoints
+        kwargs['x-api-key'] = self._auth_token
+            
         kwargs.update(self.config['base_args'])
         self.validate_params(endpoint, kwargs)
 

splitapiclient/main/harness_apiclient.py

@@ -82,13 +82,14 @@ def __init__(self, config):
         self._apikey = config.get('apikey')
         self._harness_token = config.get('harness_token')
 
-        # Store the account identifier
-        self._account_identifier = config.get('account_identifier')
-        
         # If harness_token is not provided, use apikey for all operations
-        split_auth_token = self._apikey
+        # If apikey is not provided, use harness_token for all operations
+        split_auth_token = self._apikey if self._apikey else self._harness_token
         harness_auth_token = self._harness_token if self._harness_token else self._apikey
 
+        # Store the account identifier
+        self._account_identifier = config.get('account_identifier')
+        
         # Create HTTP clients for Split endpoints
         split_http_client = HarnessHttpClient(self._base_url, split_auth_token)
         split_http_clientv3 = HarnessHttpClient(self._base_url_v3, split_auth_token)

splitapiclient/microclients/harness/service_account_microclient.py

@@ -25,7 +25,7 @@ class ServiceAccountMicroClient:
         },
         'item': {
             'method': 'GET',
-            'url_template': '/ng/api/serviceaccount/{serviceAccountId}?accountIdentifier={accountIdentifier}',
+            'url_template': '/ng/api/serviceaccount/aggregate/{serviceAccountId}?accountIdentifier={accountIdentifier}',
             'headers': [{
                 'name': 'x-api-key',
                 'template': '{value}',