esp-rainmaker-cli 1.10.0__tar.gz → 1.11.1__tar.gz

{esp_rainmaker_cli-1.10.0 → esp_rainmaker_cli-1.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esp-rainmaker-cli
-Version: 1.10.0
+Version: 1.11.1
 Summary: A python utility to perform host based claiming
 Home-page: https://github.com/espressif/esp-rainmaker-cli
 Author: Espressif Systems
@@ -115,6 +115,13 @@ Changelog
 
 All major changes to ESP RainMaker CLI will be documented in this file.
 
+## [1.11.1] - 10-Feb-2026
+- Add support for ecdsa in claiming and make it as default, with an option to fall back to the earlier rsa scheme.
+
+## [1.11.0] - 09-Feb-2026
+- Add support for Tags and Metadata during provisioning and also after mapping a user. Check `provision`
+  and `node` commands
+
 ## [1.10.0] - 22-Jan-2026
 ### Added
 - BLE local control support for `getparams`, `setparams`, and `getnodeconfig` commands during provisioning phase:

{esp_rainmaker_cli-1.10.0 → esp_rainmaker_cli-1.11.1}/esp_rainmaker_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esp-rainmaker-cli
-Version: 1.10.0
+Version: 1.11.1
 Summary: A python utility to perform host based claiming
 Home-page: https://github.com/espressif/esp-rainmaker-cli
 Author: Espressif Systems
@@ -115,6 +115,13 @@ Changelog
 
 All major changes to ESP RainMaker CLI will be documented in this file.
 
+## [1.11.1] - 10-Feb-2026
+- Add support for ecdsa in claiming and make it as default, with an option to fall back to the earlier rsa scheme.
+
+## [1.11.0] - 09-Feb-2026
+- Add support for Tags and Metadata during provisioning and also after mapping a user. Check `provision`
+  and `node` commands
+
 ## [1.10.0] - 22-Jan-2026
 ### Added
 - BLE local control support for `getparams`, `setparams`, and `getnodeconfig` commands during provisioning phase:

{esp_rainmaker_cli-1.10.0 → esp_rainmaker_cli-1.11.1}/rainmaker/rainmaker.py

@@ -7,6 +7,7 @@
 import sys
 import argparse
 from rmaker_cmd.node import *
+from rmaker_cmd.node import node_add_tags, node_remove_tags, node_set_metadata, node_delete_metadata
 from rmaker_cmd.user import signup, login, forgot_password,\
                             get_user_details, logout, set_region_configuration, \
                             profile_list, profile_current, profile_switch, profile_add, profile_remove, delete_user
@@ -483,6 +484,16 @@ def main():
                                   help='Do NOT disable challenge-response on device after successful mapping.\n'
                                        'Overrides the transport-specific default behavior.')
 
+    provision_parser.add_argument('--tags',
+                                  type=str,
+                                  help='Comma-separated list of tags to attach during node mapping\n'
+                                       '(e.g., "location:pune,name:espressif"). Tags must be in key:value format.')
+
+    provision_parser.add_argument('--metadata',
+                                  type=str,
+                                  help='Metadata as JSON string to attach during node mapping\n'
+                                       '(e.g., \'{"serial_no": "abc123", "region": "us"}\')')
+
     add_profile_argument(provision_parser)
     provision_parser.set_defaults(func=provision)
 
@@ -526,6 +537,14 @@ def main():
                               type=str,
                               help='Special RainMaker Node type (e.g., "camera").')
 
+    claim_parser.add_argument("--key_type", metavar='<key_type>',
+                              default="ecdsa",
+                              choices=['rsa', 'ecdsa'],
+                              help='Cryptographic key type for node certificate (Not applicable for Matter claiming)\n'
+                                   'ecdsa: ECDSA P-256 (smaller, faster)\n'
+                                   'rsa: RSA 2048-bit (legacy)\n'
+                                   'Default: ecdsa')
+
     add_profile_argument(claim_parser)
     claim_parser.set_defaults(func=claim_node, parser=claim_parser)
 
@@ -839,6 +858,89 @@ def main():
     add_profile_argument(group_list_nodes_parser)
     group_list_nodes_parser.set_defaults(func=group_list_nodes)
 
+    # Node Management (tags, metadata)
+    node_parser = subparsers.add_parser('node',
+                                        help='Manage node properties (tags, metadata)')
+    node_parser.set_defaults(func=lambda vars=None: node_parser.print_help())
+    node_subparsers = node_parser.add_subparsers(dest='node_command', help='Node operations')
+
+    # node add-tags
+    node_add_tags_parser = node_subparsers.add_parser('add-tags',
+                                                       help='Add tags to a node',
+                                                       description='Add tags to a node. Tags must be in key:value format.')
+    node_add_tags_parser.add_argument('nodeid',
+                                      type=str,
+                                      metavar='<nodeid>',
+                                      help='Node ID for the node')
+    node_add_tags_parser.add_argument('--tags',
+                                      type=str,
+                                      required=True,
+                                      metavar='<tags>',
+                                      help='Comma-separated list of tags in key:value format\n'
+                                           '(e.g., "location:pune,name:espressif")')
+    add_profile_argument(node_add_tags_parser)
+    node_add_tags_parser.set_defaults(func=node_add_tags)
+
+    # node remove-tags
+    node_remove_tags_parser = node_subparsers.add_parser('remove-tags',
+                                                          help='Remove tags from a node',
+                                                          description='Remove specific tags from a node.')
+    node_remove_tags_parser.add_argument('nodeid',
+                                         type=str,
+                                         metavar='<nodeid>',
+                                         help='Node ID for the node')
+    node_remove_tags_parser.add_argument('--tags',
+                                         type=str,
+                                         required=True,
+                                         metavar='<tags>',
+                                         help='Comma-separated list of tags to remove\n'
+                                              '(e.g., "location:pune,name:espressif")')
+    add_profile_argument(node_remove_tags_parser)
+    node_remove_tags_parser.set_defaults(func=node_remove_tags)
+
+    # node set-metadata
+    node_set_metadata_parser = node_subparsers.add_parser('set-metadata',
+                                                           help='Set or update metadata for a node',
+                                                           description='Set or update metadata for a node.\n'
+                                                                       'Follows shadow-style merge rules:\n'
+                                                                       '  - New keys are added, existing keys are updated\n'
+                                                                       '  - Set a key to null to delete it\n'
+                                                                       '  - Arrays are overwritten (not merged)')
+    node_set_metadata_parser.add_argument('nodeid',
+                                          type=str,
+                                          metavar='<nodeid>',
+                                          help='Node ID for the node')
+    node_set_metadata_data_group = node_set_metadata_parser.add_mutually_exclusive_group(required=True)
+    node_set_metadata_data_group.add_argument('--data',
+                                              type=str,
+                                              metavar='<json>',
+                                              help='Metadata as JSON string\n'
+                                                   '(e.g., \'{"key": "value", "region": "us"}\')')
+    node_set_metadata_data_group.add_argument('--filepath',
+                                              type=str,
+                                              metavar='<path>',
+                                              help='Path to JSON file containing metadata')
+    add_profile_argument(node_set_metadata_parser)
+    node_set_metadata_parser.set_defaults(func=node_set_metadata)
+
+    # node delete-metadata
+    node_delete_metadata_parser = node_subparsers.add_parser('delete-metadata',
+                                                              help='Delete metadata from a node',
+                                                              description='Delete metadata from a node.\n'
+                                                                          'Without --key, deletes all metadata.\n'
+                                                                          'With --key, deletes only the specified key(s).')
+    node_delete_metadata_parser.add_argument('nodeid',
+                                             type=str,
+                                             metavar='<nodeid>',
+                                             help='Node ID for the node')
+    node_delete_metadata_parser.add_argument('--key',
+                                             type=str,
+                                             metavar='<keys>',
+                                             help='Comma-separated list of metadata keys to delete\n'
+                                                  '(e.g., "region,name"). If omitted, all metadata is deleted.')
+    add_profile_argument(node_delete_metadata_parser)
+    node_delete_metadata_parser.set_defaults(func=node_delete_metadata)
+
     # Raw API command
     raw_api_parser = subparsers.add_parser('raw-api',
                                           help='Make raw API calls to RainMaker backend',

{esp_rainmaker_cli-1.10.0 → esp_rainmaker_cli-1.11.1}/rainmaker/version.py

@@ -5,4 +5,4 @@
 # SPDX-License-Identifier: Apache-2.0
 
 # This file contains the version information for the ESP RainMaker CLI
-VERSION = "1.10.0"
+VERSION = "1.11.1"

{esp_rainmaker_cli-1.10.0 → esp_rainmaker_cli-1.11.1}/rmaker_cmd/node.py

@@ -1664,7 +1664,7 @@ def claim_node(vars=None):
                 sys.exit('Invalid MAC address.')
 
         from rmaker_tools.rmaker_claim.claim import claim
-        claim(port=vars['port'], node_platform=vars['platform'], mac_addr=vars['mac'], flash_address=vars['addr'], matter=vars['matter'], out_dir=vars['outdir'], node_type=vars['type'])
+        claim(port=vars['port'], node_platform=vars['platform'], mac_addr=vars['mac'], flash_address=vars['addr'], matter=vars['matter'], out_dir=vars['outdir'], node_type=vars['type'], key_type=vars['key_type'])
     except Exception as claim_err:
         log.error(claim_err)
         return
@@ -1878,3 +1878,203 @@ def raw_api_call(vars=None):
         traceback.print_exc()
     return
 
+
+def node_add_tags(vars=None):
+    """
+    Add tags to a node.
+
+    :param vars: Parameters:
+                 `nodeid` as key - Node ID for the node
+                 `tags` as key - Comma-separated list of tags (key:value format)
+                 `profile` as key - Profile to use for the operation
+    :type vars: dict | None
+
+    :return: None on Success
+    :rtype: None
+    """
+    try:
+        s = get_session_with_profile(vars or {})
+        node_id = vars.get('nodeid')
+        tags_str = vars.get('tags')
+
+        if not node_id:
+            print("Error: Node ID is required.")
+            return
+        if not tags_str:
+            print("Error: Tags are required.")
+            return
+
+        # Parse comma-separated tags
+        tags = [t.strip() for t in tags_str.split(',') if t.strip()]
+
+        # Validate tag format (key:value)
+        for tag in tags:
+            if ':' not in tag:
+                print(f"Error: Invalid tag format '{tag}'. Tags must be in key:value format.")
+                return
+
+        n = node.Node(node_id, s)
+        response = n.update_node_tags(tags)
+
+        if response.get('status') == 'success':
+            print(f"Tags added to node {node_id} successfully.")
+        else:
+            description = response.get('description', 'Unknown error')
+            print(f"Failed to add tags: {description}")
+
+    except Exception as e:
+        log.error(f"Error adding tags: {e}")
+
+
+def node_remove_tags(vars=None):
+    """
+    Remove tags from a node.
+
+    :param vars: Parameters:
+                 `nodeid` as key - Node ID for the node
+                 `tags` as key - Comma-separated list of tags to remove (key:value format)
+                 `profile` as key - Profile to use for the operation
+    :type vars: dict | None
+
+    :return: None on Success
+    :rtype: None
+    """
+    try:
+        s = get_session_with_profile(vars or {})
+        node_id = vars.get('nodeid')
+        tags_str = vars.get('tags')
+
+        if not node_id:
+            print("Error: Node ID is required.")
+            return
+        if not tags_str:
+            print("Error: Tags are required.")
+            return
+
+        # Parse comma-separated tags
+        tags = [t.strip() for t in tags_str.split(',') if t.strip()]
+
+        n = node.Node(node_id, s)
+        response = n.remove_node_tags(tags)
+
+        if response.get('status') == 'success':
+            print(f"Tags removed from node {node_id} successfully.")
+        else:
+            description = response.get('description', 'Unknown error')
+            print(f"Failed to remove tags: {description}")
+
+    except Exception as e:
+        log.error(f"Error removing tags: {e}")
+
+
+def node_set_metadata(vars=None):
+    """
+    Set or update metadata for a node. Follows shadow-style merge rules:
+    - New keys are added, existing keys are updated
+    - To delete a specific key, set its value to null in the JSON
+
+    :param vars: Parameters:
+                 `nodeid` as key - Node ID for the node
+                 `data` as key - JSON string of metadata to set
+                 `filepath` as key - Path to JSON file containing metadata
+                 `profile` as key - Profile to use for the operation
+    :type vars: dict | None
+
+    :return: None on Success
+    :rtype: None
+    """
+    try:
+        s = get_session_with_profile(vars or {})
+        node_id = vars.get('nodeid')
+
+        if not node_id:
+            print("Error: Node ID is required.")
+            return
+
+        # Parse metadata from --data or --filepath
+        data_str = vars.get('data')
+        filepath = vars.get('filepath')
+
+        if not data_str and not filepath:
+            print("Error: Either --data or --filepath is required.")
+            return
+
+        metadata = None
+        if data_str:
+            try:
+                metadata = json.loads(data_str)
+            except json.JSONDecodeError as e:
+                print(f"Error: Invalid JSON in --data: {e}")
+                return
+        elif filepath:
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    metadata = json.load(f)
+            except FileNotFoundError:
+                print(f"Error: File not found: {filepath}")
+                return
+            except json.JSONDecodeError as e:
+                print(f"Error: Invalid JSON in file {filepath}: {e}")
+                return
+
+        n = node.Node(node_id, s)
+        response = n.update_node_metadata(metadata)
+
+        if response.get('status') == 'success':
+            print(f"Metadata updated for node {node_id} successfully.")
+        else:
+            description = response.get('description', 'Unknown error')
+            print(f"Failed to update metadata: {description}")
+
+    except Exception as e:
+        log.error(f"Error updating metadata: {e}")
+
+
+def node_delete_metadata(vars=None):
+    """
+    Delete metadata from a node.
+    Without --key, deletes all metadata.
+    With --key, deletes only the specified key(s).
+
+    :param vars: Parameters:
+                 `nodeid` as key - Node ID for the node
+                 `key` as key - Comma-separated list of metadata keys to delete (optional)
+                 `profile` as key - Profile to use for the operation
+    :type vars: dict | None
+
+    :return: None on Success
+    :rtype: None
+    """
+    try:
+        s = get_session_with_profile(vars or {})
+        node_id = vars.get('nodeid')
+
+        if not node_id:
+            print("Error: Node ID is required.")
+            return
+
+        key_str = vars.get('key')
+
+        n = node.Node(node_id, s)
+
+        if key_str:
+            # Delete specific keys by setting them to None
+            keys = [k.strip() for k in key_str.split(',') if k.strip()]
+            metadata = {k: None for k in keys}
+            response = n.update_node_metadata(metadata)
+            key_list = ', '.join(keys)
+            success_msg = f"Metadata key(s) '{key_list}' deleted from node {node_id} successfully."
+        else:
+            # Delete all metadata by sending null
+            response = n.update_node_metadata(None)
+            success_msg = f"All metadata deleted from node {node_id} successfully."
+
+        if response.get('status') == 'success':
+            print(success_msg)
+        else:
+            description = response.get('description', 'Unknown error')
+            print(f"Failed to delete metadata: {description}")
+
+    except Exception as e:
+        log.error(f"Error deleting metadata: {e}")
+

{esp_rainmaker_cli-1.10.0 → esp_rainmaker_cli-1.11.1}/rmaker_cmd/provision.py

@@ -123,6 +123,19 @@ def provision(vars=None):
         passphrase = vars.get('passphrase')
         no_wifi = vars.get('no_wifi', False)
 
+        # Parse tags and metadata for node mapping
+        mapping_tags = None
+        mapping_metadata = None
+        tags_str = vars.get('tags')
+        metadata_str = vars.get('metadata')
+        if tags_str:
+            mapping_tags = [t.strip() for t in tags_str.split(',') if t.strip()]
+        if metadata_str:
+            try:
+                mapping_metadata = json.loads(metadata_str)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Invalid JSON in --metadata: {e}")
+
         # Generate secret key for user-node mapping
         secret_key = str(uuid.uuid4())
 
@@ -182,7 +195,9 @@ def provision(vars=None):
                 sec_ver_override=sec_ver,
                 discovery_timeout=discovery_timeout,
                 interactive=True,
-                disable_on_success=disable_chal_resp
+                disable_on_success=disable_chal_resp,
+                tags=mapping_tags,
+                metadata=mapping_metadata
             )
 
             if success and node_id:
@@ -220,7 +235,9 @@ def provision(vars=None):
                 session=curr_session,
                 no_retry=vars.get('no_retry', False),
                 no_wifi=no_wifi,
-                disable_chal_resp=disable_chal_resp
+                disable_chal_resp=disable_chal_resp,
+                tags=mapping_tags,
+                metadata=mapping_metadata
             )
         except RuntimeError as claim_err:
             # Handle claim requirement error specifically
@@ -272,7 +289,7 @@ def provision(vars=None):
         try:
             log.info('Adding node to user account...')
             node_obj = node.Node(node_id, curr_session)
-            request_id = node_obj.add_user_node_mapping(secret_key)
+            request_id = node_obj.add_user_node_mapping(secret_key, tags=mapping_tags, metadata=mapping_metadata)
             if not request_id:
                 print(f'⚠️  Warning: Node provisioned but failed to add to account')
                 log.warning('add_user_node_mapping returned None')

{esp_rainmaker_cli-1.10.0 → esp_rainmaker_cli-1.11.1}/rmaker_lib/node.py

@@ -340,7 +340,7 @@ class Node:
         log.info(f"Updating parameters for {len(node_params_list)} nodes")
         return Node._set_params_api(node_params_list, session.config, session.request_header)
 
-    def __user_node_mapping(self, secret_key, operation):
+    def __user_node_mapping(self, secret_key, operation, tags=None, metadata=None):
         """
         Add or remove the user node mapping.
 
@@ -352,6 +352,12 @@ class Node:
                           'add' or 'remove'
         :type operation: str
 
+        :param tags: Optional list of tags to attach during mapping (format: ["key:value", ...])
+        :type tags: list | None
+
+        :param metadata: Optional metadata dict to attach during mapping
+        :type metadata: dict | None
+
         :raises NetworkError: If there is a network connection issue
                               while adding user node mapping
         :raises Exception: If there is an HTTP issue or JSON format issue
@@ -371,6 +377,11 @@ class Node:
             'operation': operation
         }
 
+        if tags:
+            request_payload['tags'] = tags
+        if metadata:
+            request_payload['metadata'] = metadata
+
         # Get fresh token (will refresh if expired) before making API call
         # This prevents "Unauthorized" errors if token expired during provisioning
         try:
@@ -419,7 +430,7 @@ class Node:
             return response['request_id']
         return None
 
-    def add_user_node_mapping(self, secret_key):
+    def add_user_node_mapping(self, secret_key, tags=None, metadata=None):
         """
         Add user node mapping.
 
@@ -427,6 +438,12 @@ class Node:
                             used for User-Node mapping
         :type secret_key: str
 
+        :param tags: Optional list of tags to attach during mapping (format: ["key:value", ...])
+        :type tags: list | None
+
+        :param metadata: Optional metadata dict to attach during mapping
+        :type metadata: dict | None
+
         :raises NetworkError: If there is a network connection issue while
                               adding user node mapping
         :raises Exception: If there is an HTTP issue while
@@ -438,7 +455,7 @@ class Node:
         """
         log.info("Adding user node mapping request with nodeid : " +
                  self.__nodeid)
-        return self.__user_node_mapping(secret_key, 'add')
+        return self.__user_node_mapping(secret_key, 'add', tags=tags, metadata=metadata)
 
     def remove_user_node_mapping(self):
         """
@@ -845,6 +862,163 @@ class Node:
             raise get_nodes_params_err
 
         response = json.loads(response.text)
-        log.debug("Received shared nodes successfully.")
+        log.debug("Received sharing requests successfully.")
+
+        return response
+
+    def update_node_tags(self, tags):
+        """
+        Add tags to a node.
+        Uses PUT /v1/user/nodes?node_id=<node_id>
+
+        :param tags: List of tags to add (format: ["key:value", ...])
+        :type tags: list
+
+        :raises NetworkError: If there is a network connection issue
+        :raises Exception: If there is an HTTP issue while updating tags
+
+        :return: API response on Success
+        :rtype: dict
+        """
+        socket.setdefaulttimeout(10)
+        log.info("Adding tags to node : " + self.__nodeid)
+        path = 'user/nodes'
+        query_parameters = 'node_id=' + self.__nodeid
+        url = self.config.get_host() + path + '?' + query_parameters
+
+        payload = {'tags': tags}
+
+        try:
+            log.debug("Update node tags request url : " + url)
+            log.debug("Update node tags request payload : " + json.dumps(payload))
+            response = requests.put(url=url,
+                                    headers=self.request_header,
+                                    json=payload,
+                                    verify=configmanager.CERT_FILE,
+                                    timeout=(5.0, 5.0))
+            log.debug("Update node tags response : " + response.text)
+            response.raise_for_status()
+
+        except HTTPError as http_err:
+            log.debug(http_err)
+            raise HttpErrorResponse(response.json())
+        except requests.exceptions.SSLError:
+            raise SSLError
+        except requests.exceptions.ConnectionError:
+            raise NetworkError
+        except Timeout as time_err:
+            log.debug(time_err)
+            raise RequestTimeoutError
+        except RequestException as req_err:
+            log.debug(req_err)
+            raise req_err
+
+        response = json.loads(response.text)
+        log.info("Added tags to node successfully.")
+        return response
+
+    def remove_node_tags(self, tags):
+        """
+        Remove tags from a node.
+        Uses DELETE /v1/user/nodes?node_id=<node_id>
+
+        :param tags: List of tags to remove (format: ["key:value", ...])
+        :type tags: list
+
+        :raises NetworkError: If there is a network connection issue
+        :raises Exception: If there is an HTTP issue while removing tags
+
+        :return: API response on Success
+        :rtype: dict
+        """
+        socket.setdefaulttimeout(10)
+        log.info("Removing tags from node : " + self.__nodeid)
+        path = 'user/nodes'
+        query_parameters = 'node_id=' + self.__nodeid
+        url = self.config.get_host() + path + '?' + query_parameters
 
+        payload = {'tags': tags}
+
+        try:
+            log.debug("Remove node tags request url : " + url)
+            log.debug("Remove node tags request payload : " + json.dumps(payload))
+            response = requests.delete(url=url,
+                                       headers=self.request_header,
+                                       json=payload,
+                                       verify=configmanager.CERT_FILE,
+                                       timeout=(5.0, 5.0))
+            log.debug("Remove node tags response : " + response.text)
+            response.raise_for_status()
+
+        except HTTPError as http_err:
+            log.debug(http_err)
+            raise HttpErrorResponse(response.json())
+        except requests.exceptions.SSLError:
+            raise SSLError
+        except requests.exceptions.ConnectionError:
+            raise NetworkError
+        except Timeout as time_err:
+            log.debug(time_err)
+            raise RequestTimeoutError
+        except RequestException as req_err:
+            log.debug(req_err)
+            raise req_err
+
+        response = json.loads(response.text)
+        log.info("Removed tags from node successfully.")
+        return response
+
+    def update_node_metadata(self, metadata):
+        """
+        Update metadata for a node. Follows shadow-style merge rules:
+        - {"key": value} upserts that key
+        - {"key": null} deletes that key
+        - null (top-level) deletes all metadata
+
+        Uses PUT /v1/user/nodes?node_id=<node_id>
+
+        :param metadata: Metadata dict to set/update, or None to delete all
+        :type metadata: dict | None
+
+        :raises NetworkError: If there is a network connection issue
+        :raises Exception: If there is an HTTP issue while updating metadata
+
+        :return: API response on Success
+        :rtype: dict
+        """
+        socket.setdefaulttimeout(10)
+        log.info("Updating metadata for node : " + self.__nodeid)
+        path = 'user/nodes'
+        query_parameters = 'node_id=' + self.__nodeid
+        url = self.config.get_host() + path + '?' + query_parameters
+
+        payload = {'metadata': metadata}
+
+        try:
+            log.debug("Update node metadata request url : " + url)
+            log.debug("Update node metadata request payload : " + json.dumps(payload))
+            response = requests.put(url=url,
+                                    headers=self.request_header,
+                                    json=payload,
+                                    verify=configmanager.CERT_FILE,
+                                    timeout=(5.0, 5.0))
+            log.debug("Update node metadata response : " + response.text)
+            response.raise_for_status()
+
+        except HTTPError as http_err:
+            log.debug(http_err)
+            raise HttpErrorResponse(response.json())
+        except requests.exceptions.SSLError:
+            raise SSLError
+        except requests.exceptions.ConnectionError:
+            raise NetworkError
+        except Timeout as time_err:
+            log.debug(time_err)
+            raise RequestTimeoutError
+        except RequestException as req_err:
+            log.debug(req_err)
+            raise req_err
+
+        response = json.loads(response.text)
+        log.info("Updated node metadata successfully.")
         return response