follow create network process id

Author: qrkourier

netfoundry/ctl.py

@@ -805,7 +805,8 @@ def demo(cli):
             network_created = network_group.create_network(
                 name=network_name,
                 size=cli.config.demo.size,
-                version=cli.config.demo.product_version)
+                version=cli.config.demo.product_version,
+                wait=600)
             network, network_group = use_network(
                 organization=organization,
                 group=cli.config.general.network_group,

netfoundry/network.py

@@ -3,13 +3,12 @@
 import json
 import logging
 import re
-import sys
 import time
 
 from netfoundry.exceptions import UnknownResourceType
 
-from .utility import (DC_PROVIDERS, MUTABLE_NET_RESOURCES, NET_RESOURCES, RESOURCES, STATUS_CODES, VALID_SEPARATORS, VALID_SERVICE_PROTOCOLS, any_in, docstring_parameters, find_generic_resources,
-                      get_generic_resource, http, is_uuidv4, normalize_caseless, plural, singular)
+from .utility import (DC_PROVIDERS, MUTABLE_NET_RESOURCES, NET_RESOURCES, PROCESS_STATUS_SYMBOLS, RESOURCES, STATUS_CODES, VALID_SEPARATORS, VALID_SERVICE_PROTOCOLS, any_in, docstring_parameters, find_generic_resources, get_generic_resource, http,
+                      is_uuidv4, normalize_caseless, plural, singular)
 
 
 class Network:
@@ -2035,3 +2034,36 @@ def get_network_domain_resource(self,  resource_type: str, id: str, **kwargs):
         headers = {"authorization": "Bearer " + self.token}
         resource = get_generic_resource(url=url, headers=headers, proxies=self.proxies, verify=self.verify, **params)
         return(resource)
+
+    def wait_for_process(self, process_id: str, expected_statuses: list, wait: int = 300, sleep: int = 3, id: str = None):
+        """Continuously poll for the expected statuses until expiry.
+
+        :param expected_statuses: list of strings as expected status symbol(s) e.g. ["PROVISIONING","PROVISIONED"]
+        :param wait: optional SECONDS after which to raise an exception defaults to five minutes (300)
+        :param sleep: SECONDS polling interval
+        """
+        now = time.time()
+        if not wait >= sleep:
+            raise RuntimeError(f"wait duration ({wait}) must be greater than or equal to polling interval ({sleep})")
+        unexpected_statuses = PROCESS_STATUS_SYMBOLS['error']
+        logging.debug(f"waiting for any status in {expected_statuses} for {type} with id {id} or until {time.ctime(now+wait)}.")
+        status = 'NEW'
+        url = f"{self.audience}core/v2/process-executions/{process_id}"
+        headers = {"authorization": "Bearer " + self.token}
+        time.sleep(sleep)                          # allow minimal time for the resource status to become available
+        while time.time() < now+wait and status not in expected_statuses:
+            entity_status, status_symbol = get_generic_resource(url, headers, self.proxies, self.verify)
+            if entity_status['status']:            # attribute is not None if HTTP OK
+                status = entity_status['status']
+                logging.debug(f"{entity_status['name']} has status {entity_status['status']}")
+            if status in unexpected_statuses:
+                raise RuntimeError(f"got status {status} while waiting for {expected_statuses}")
+            elif status not in expected_statuses:
+                time.sleep(sleep)
+
+        if status in expected_statuses:
+            return True
+        elif not status:
+            raise RuntimeError(f"failed to read status while waiting for any status in {expected_statuses}; got {entity_status['http_status']} ({entity_status['response_code']})")
+        else:
+            raise RuntimeError(f"timed out with status {status} while waiting for any status in {expected_statuses}")

netfoundry/network_group.py

@@ -6,6 +6,7 @@
 from .utility import (NET_RESOURCES, RESOURCES, STATUS_CODES,
                       find_generic_resources, get_generic_resource, http, is_uuidv4,
                       normalize_caseless, any_in)
+from .network import Networks
 
 
 class NetworkGroup:
@@ -16,6 +17,7 @@ class NetworkGroup:
 
     def __init__(self, Organization: object, network_group_id: str = None, network_group_name: str = None, group: str = None):
         """Initialize the network group class with a group name or ID."""
+        self.Networks = Networks(Organization)
         self.network_groups = Organization.get_network_groups_by_organization()
         if (not network_group_id and not network_group_name) and group:
             if is_uuidv4(group):
@@ -159,7 +161,7 @@ def find_latest_product_version(self, product_versions: list = list(), is_active
         from distutils.version import LooseVersion
         return sorted(product_versions, key=LooseVersion)[-1]
 
-    def create_network(self, name: str, network_group_id: str = None, location: str = "us-east-1", version: str = None, size: str = "small", **kwargs):
+    def create_network(self, name: str, network_group_id: str = None, location: str = "us-east-1", version: str = None, size: str = "small", wait: int = 0, sleep: int = 10, **kwargs):
         """
         Create a network in this network group.
 
@@ -231,11 +233,27 @@ def create_network(self, name: str, network_group_id: str = None, location: str
         # the HTTP response code is one of the expected responses for creating a network
         response_code_symbols = [s.upper() for s in STATUS_CODES._codes[response_code]]
         if any_in(response_code_symbols, RESOURCES['networks'].create_responses):
-            network = response.json()
-            return(network)
+            resource = response.json()
         else:
             raise RuntimeError(f"got unexpected HTTP code {STATUS_CODES._codes[response_code][0].upper()} ({response_code}) and response {response.text}")
 
+        if resource.get('_links') and resource['_links'].get('process-executions'):
+            _links = resource['_links'].get('process-executions')
+            if isinstance(_links, list):
+                process_id = _links[0]['href'].split('/')[6]
+            else:
+                process_id = _links['href'].split('/')[6]
+            if wait:
+                self.Networks.wait_for_process(process_id, RESOURCES["process-executions"].status_symbols['complete'], wait=wait, sleep=sleep)
+                resource = self.get_resource_by_id(type="network", id=resource['id'])
+                return(resource)
+            else:    # only wait for the process to start, not finish, or timeout
+                self.Networks.wait_for_process(process_id, RESOURCES['process-executions'].status_symbols['progress'] + RESOURCES['process-executions'].status_symbols['complete'], type="process-executions", wait=9, sleep=3)
+                return(resource)
+        elif wait:
+            logging.warning("unable to wait for async complete because response did not provide a process execution id")
+            return(resource)
+
     def delete_network(self, network_id=None, network_name=None):
         """
         Delete a network.

netfoundry/utility.py

@@ -282,7 +282,10 @@ def get_generic_resource(url: str, headers: dict, proxies: dict = dict(), verify
             if len(resources) == 1:
                 resource = resources[0]
             else:
-                resource = {"status": "NEW"}
+                resource = {
+                    "status": "NEW",
+                    "name": "NONAME"
+                }
         elif not status_symbol == 'NOT_FOUND':  # tolerate 404 because some functions will conclude that the resource has been deleted as expected
             raise
     else: