feat: Adding Examples for Python SDK to create FCR and FCR based Connections

examples/services/fabricv4/__init__.py

@@ -0,0 +1 @@
+__all__ = ['cloud_router','connections','utils','oauth2']

examples/services/fabricv4/cloud_router/__init__.py

@@ -0,0 +1 @@
+__all__ = ['cloud_router','cloud_router_management']

examples/services/fabricv4/cloud_router/cloud_router.py

@@ -0,0 +1,73 @@
+from equinix.services.fabricv4 import CloudRouterPostRequest, CloudRouterChangeOperation
+from examples.services.fabricv4.utils import utils
+from equinix.services import fabricv4
+import cloud_router_management
+
+
+if __name__ == "__main__":
+
+    """
+    Create a Fabric Cloud Router (FCR) using the Equinix Fabric API.
+
+    This method sends a request to create a new Fabric Cloud Router with specified configurations 
+    such as router type, name, location, package, and associated project and account details. 
+    Notifications are also configured to receive updates regarding the router.
+    """
+
+    utils.pr_yellow('\nCreate Fabric Cloud Router')
+    fcr_request = CloudRouterPostRequest(
+        type="XF_ROUTER",
+        name="Python_FCR",
+        location={"metro_code": "SV"},
+        package={"code": "STANDARD"},
+        order={"purchase_order_number": "1-14535"},
+        project={"project_id": "123456877663"},
+        account={"account_number": 123456},
+        notifications=[
+            {
+                "type": "ALL",
+                "emails": [
+                    "[email protected]"
+                ]
+            }
+        ]
+    )
+    fcr_uuid = cloud_router_management.create_fcr(fcr_request)
+
+    """
+    Retrieve the details of a Fabric Cloud Router using its UUID.
+
+    This method fetches and returns the detailed information associated with a specific
+    Fabric Cloud Router, identified by its UUID. It interacts with the Equinix Fabric API
+    to retrieve the cloud router's data, such as its configuration, status, and related
+    connections.
+    """
+
+    utils.pr_yellow('\nGet Fabric Cloud Router Details by UUID')
+    cloud_router_management.get_fcr_uuid(fcr_uuid)
+
+    """
+    Updates the name of a Fabric Cloud Router (FCR) using its UUID.
+
+    This method performs an update operation on a specified Fabric Cloud Router by replacing
+    the current name with a new one. It leverages the Equinix Fabric API to execute this change.
+    """
+
+    update_name = [CloudRouterChangeOperation(
+        op="replace",
+        path="/name",
+        value="panthers-test-updated1"
+    )]
+    cloud_router_management.update_fcr_by_uuid(fcr_uuid,update_name)
+
+    """
+    Deletes a Fabric Cloud Router (FCR) with the specified UUID.
+
+    This method handles the deletion of a Fabric Cloud Router by calling the
+    relevant function in the `cloud_router_management` module. It first prints
+    a message to the console indicating the start of the deletion process,
+    using a yellow color for emphasis. After that, it proceeds to delete the
+    specified Fabric Cloud Router.
+    """
+    utils.pr_yellow('\nDelete Fabric Cloud Router')
+    cloud_router_management.delete_fcr(fcr_uuid)

examples/services/fabricv4/cloud_router/cloud_router_management.py

@@ -0,0 +1,66 @@
+import json
+import time
+
+from icecream import ic
+from examples.services.fabricv4.utils import utils
+from examples.services.fabricv4.oauth2 import configure_client_credentials
+from examples.services import fabricv4
+from equinix.services import fabricv4
+
+
+def create_fcr(fcr_request):
+    """
+    Create a Fabric Cloud Router (FCR) using the provided request payload.
+    """
+    utils.pr_purple('\nCreate FCR request payload:\n')
+    ic(fcr_request.to_json())
+    client = configure_client_credentials.get_equinix_fabric_client()
+    cloudrouterapicall = fabricv4.CloudRoutersApi(client)
+    response = cloudrouterapicall.create_cloud_router(fcr_request).to_json()
+    json_resp = json.loads(response)
+    json_formatted_str = json.dumps(json_resp, sort_keys=True, indent=4)
+    time.sleep(15)
+    utils.pr_cyan('\nCloud router creation response\n')
+    ic(json_formatted_str)
+    utils.pr_cyan('\nconnection_uuid = ' + json_resp['uuid'])
+    return json_resp['uuid']
+
+
+def get_fcr_uuid(fcr_uuid):
+    """
+    Retrieve the details of an existing Fabric Cloud Router (FCR) by its UUID.
+    """
+    client = configure_client_credentials.get_equinix_fabric_client()
+    cloudrouterapicall = fabricv4.CloudRoutersApi(client)
+    response = cloudrouterapicall.get_cloud_router_by_uuid(fcr_uuid).to_json()
+    json_resp = json.loads(response)
+    json_formatted_str = json.dumps(json_resp, sort_keys=True, indent=4)
+    time.sleep(15)
+    ic('\nget FCR response = ', json_formatted_str)
+    ic('\nFCR Get Successfully\n')
+
+
+def update_fcr_by_uuid(fcr_uuid, update_payload):
+    """
+    Update an existing Fabric Cloud Router (FCR) using the provided UUID and update payload.
+    """
+    client = configure_client_credentials.get_equinix_fabric_client()
+    cloudrouterapicall = fabricv4.CloudRoutersApi(client)
+    response = cloudrouterapicall.update_cloud_router_by_uuid(fcr_uuid, update_payload).to_json()
+    json_resp = json.loads(response)
+    json_formatted_str = json.dumps(json_resp, sort_keys=True, indent=4)
+    time.sleep(15)
+    ic('\nupdate FCR response = ', json_formatted_str)
+    ic('\nFCR updated Successfully\n')
+
+
+def delete_fcr(fcr_uuid):
+    """
+    Delete an existing Fabric Cloud Router (FCR) using the provided UUID.
+    """
+    client = configure_client_credentials.get_equinix_fabric_client()
+    cloudrouterapicall = fabricv4.CloudRoutersApi(client)
+    response = cloudrouterapicall.delete_cloud_router_by_uuid(fcr_uuid)
+    time.sleep(15)
+    ic('\ndelete FCR response = ', response)
+    ic('\nFCR Deleted Successfully\n')

examples/services/fabricv4/connections/__init__.py

@@ -0,0 +1 @@
+__all__ = ['connection_management','fcr_2_aws_connection','fcr_2_port_connection','fcr_2_azure_connection']

examples/services/fabricv4/connections/connection_management.py

@@ -0,0 +1,105 @@
+import json
+import time
+
+
+from icecream import ic
+from examples.services.fabricv4.utils import utils
+from examples.services.fabricv4.oauth2 import configure_client_credentials
+from examples.services import fabricv4
+from equinix.services import fabricv4
+
+
+def create_fcr_connection(fcr_uuid, fcr2colo_request):
+    """
+    Create a connection for a Fabric Cloud Router (FCR) within the Equinix Fabric environment.
+
+    This method handles the process of establishing a connection between a Fabric Cloud Router (FCR) and a
+    colocation or another FCR within the Equinix Fabric. It generates the connection request payload,
+    sends the request to the Equinix Fabric API, and returns the unique identifier (UUID) of the created connection.
+    """
+    utils.pr_purple('\nFCR Connection Request Payload:\n')
+    ic(fcr2colo_request.to_json())
+    client = configure_client_credentials.get_equinix_fabric_client()
+    connections = fabricv4.ConnectionsApi(client)
+    response = dict(connections.create_connection(fcr2colo_request))
+    pretty_json = json.dumps(response, indent=4, default=utils.custom_serializer)
+    time.sleep(20)
+    utils.pr_cyan('\nFCR Connection response\n')
+    ic(pretty_json)
+    utils.pr_cyan('\nfcr_conn_response = '+response['uuid'])
+    return response['uuid']
+
+
+def configure_routing_protocol(connection_uuid,routing_protocol_request):
+    """
+    Configures a routing protocol for a specified connection in the Equinix Fabric.
+
+    This method sets up a routing protocol for the given connection UUID using the
+    specified routing protocol request. The method leverages the Equinix Fabric API
+    to create the routing protocol associated with the connection. The response from
+    the API is formatted and printed for verification.
+
+    This would configure a BGP routing protocol for the specified connection, using
+    the provided ASNs and authentication key, and then print the response from the
+    Equinix Fabric API.
+    """
+    rp_type = fabricv4.RoutingProtocolBase(routing_protocol_request)
+    client = configure_client_credentials.get_equinix_fabric_client()
+    routing_protocol = fabricv4.RoutingProtocolsApi(client)
+    response = dict(routing_protocol.create_connection_routing_protocol(connection_uuid, rp_type))
+    json_formatted_str = json.dumps(response, indent=4, default=utils.custom_serializer)
+    time.sleep(15)
+    ic('\nconfigure routing protocol = ', json_formatted_str)
+    ic('\nrouting protocol configured successful\n')
+
+
+def get_connection_details_by_uuid(fcr_uuid):
+    """
+    Retrieve connection details using the unique identifier (UUID) of a Fabric Cloud Router (FCR) connection.
+
+    This method interacts with the Equinix Fabric API to fetch detailed information about a specific connection
+    identified by its UUID. The response is then formatted into a JSON string for easier readability and logged
+    for debugging purposes.
+    """
+    client = configure_client_credentials.get_equinix_fabric_client()
+    cloudrouterapicall = fabricv4.ConnectionsApi(client)
+    response = dict(cloudrouterapicall.get_connection_by_uuid(fcr_uuid))
+    json_formatted_str = json.dumps(response, indent=4, default=utils.custom_serializer)
+    time.sleep(15)
+    ic('\nget connection details response = ', json_formatted_str)
+    ic('\ngot connection details successful\n')
+
+
+def update_connection_details_by_uuid(connection_uuid,update_payload):
+    """
+    Updates the details of an existing connection in Equinix Fabric using its UUID.
+
+    This method sends an update request to the Equinix Fabric API to modify the details of a
+    connection specified by its UUID. The updated details are provided through the update_payload
+    parameter. After the update, the method formats the response into a JSON string and logs
+    the updated connection details.
+    """
+    client = configure_client_credentials.get_equinix_fabric_client()
+    cloudrouterapicall = fabricv4.ConnectionsApi(client)
+    response = dict(cloudrouterapicall.update_connection_by_uuid(connection_uuid,update_payload))
+    json_formatted_str = json.dumps(response, indent=4, default=utils.custom_serializer)
+    time.sleep(15)
+    ic('\nupdate connection details = ', json_formatted_str)
+    ic('\nconnections details updated successful\n')
+
+
+def delete_connection(con_uuid):
+    """
+    Deletes a connection from the Equinix Fabric using the connection UUID.
+
+    This method interacts with the Equinix Fabric API to delete a specified connection.
+    The method retrieves a configured client for the Equinix Fabric, utilizes the
+    ConnectionsApi to perform the deletion, and then logs the response.
+    """
+    client = configure_client_credentials.get_equinix_fabric_client()
+    connections = fabricv4.ConnectionsApi(client)
+    response = connections.delete_connection_by_uuid_with_http_info(con_uuid).json
+    pretty_json = json.dumps(response, indent=4, default=utils.custom_serializer)
+    time.sleep(15)
+    ic('\ndelete connection response = ', pretty_json)
+    ic('\nConnection Deleted Successfully\n')

examples/services/fabricv4/connections/fcr_2_aws_connection.py

@@ -0,0 +1,137 @@
+import time
+import os
+
+from equinix.services.fabricv4 import (CloudRouterPostRequest, ConnectionPostRequest,
+                                       RoutingProtocolDirectType, ConnectionChangeOperation)
+from examples.services.fabricv4.utils import utils
+from examples.services.fabricv4.cloud_router import cloud_router_management
+from examples.services.fabricv4.connections import connection_management
+
+if __name__ == "__main__":
+    """
+    Create a Fabric Cloud Router (FCR) using the Equinix Fabric API.
+    """
+
+    utils.pr_yellow('\nCreate Fabric Cloud Router')
+    fcr_request = CloudRouterPostRequest(
+        type="XF_ROUTER",
+        name="fcrtoawsfcr_01",
+        location={"metro_code": "SV"},
+        package={"code": "STANDARD"},
+        order={"purchase_order_number": "1-1453534"},
+        project={"project_id": "xxxx22-xxxx-xxxx-xxxx"},
+        account={"account_number": 123456},
+        notifications=[
+            {
+                "type": "ALL",
+                "emails": [
+                    "[email protected]"
+                ]
+            }
+        ]
+    )
+    fcr_uuid = cloud_router_management.create_fcr(fcr_request)
+
+    """
+    Create a Fabric Cloud Router (FCR) to AWS Connection.
+    """
+    utils.pr_yellow('\nCreate Fabric Cloud Router to AWS Connection')
+    fcr2aws_request = ConnectionPostRequest(
+        type="IP_VC",
+        name="fcr2aws_conn_python_01",
+        bandwidth=50,
+        redundancy={
+            "priority": "PRIMARY"
+        },
+        a_side={
+            "accessPoint": {
+                "type": "CLOUD_ROUTER",
+                "router": {
+                    "uuid": fcr_uuid
+                }
+            }
+        },
+        z_side={
+            "accessPoint": {
+                "type": "SP",
+                "profile": {
+                    "type": "L2_PROFILE",
+                    "uuid": "3435fefrr-4534ffvrt-45345dvff-cvvvv"
+                },
+                "location": {
+                    "metroCode": "SV"
+                },
+                "sellerRegion": "us-west-1",
+                "authenticationKey": os.getenv("AWS_AUTH_KEY")
+            }
+        },
+        project={"project_id": "xxxx22-xxxx-xxxx-xxxx"},
+        notifications=[
+            {
+                "type": "ALL",
+                "emails": [
+                    "[email protected]"
+                ]
+            }
+        ]
+    )
+    fcr2aws = connection_management.create_fcr_connection(fcr_uuid, fcr2aws_request)
+
+    """
+    Configures a routing protocol for a Fabric Cloud Router (FCR) to AWS connection identified by the provided 
+    connection UUID.
+    """
+    utils.pr_yellow('\nConfigure Routing Protocol Detail by UUID')
+    routing_protocol_request = RoutingProtocolDirectType(
+        type="DIRECT",
+        directIpv4={
+            "equinixIfaceIp": 'ip'
+        }
+    )
+    connection_management.configure_routing_protocol(fcr2aws, routing_protocol_request)
+
+    """
+    Accepts an AWS connection from the Equinix Fabric using the AWS_ACCESS_KEY and AWS_SECRET_KEY.
+    """
+    utils.pr_yellow('\nAccepting AWS Connection using AWS_ACCESS_KEY and AWS_SECRET_KEY')
+    aws_accept_connection = [ConnectionChangeOperation(
+        op="add",
+        path="",
+        value={
+            "additionalInfo": [
+                {
+                    "key": "accessKey",
+                    "value": os.getenv("AWS_ACCESS_KEY")
+                },
+                {
+                    "key": "secretKey",
+                    "value": os.getenv("AWS_SECRET_KEY")
+                }
+            ]
+        }
+    )
+    ]
+    connection_management.update_connection_details_by_uuid(fcr2aws, aws_accept_connection)
+
+    """
+    Retrieves the connection details for a Fabric Cloud Router (FCR) to AWS connection by its UUID.
+    This method is primarily used to fetch detailed information about a specific connection between 
+    a Fabric Cloud Router and AWS, using the connection's unique identifier (UUID). 
+    """
+    utils.pr_yellow('\nGet FCR2AWS Connection Details by UUID')
+    time.sleep(120)
+    connection_management.get_connection_details_by_uuid(fcr2aws)
+
+    """
+    Deletes a Fabric Cloud Router (FCR) to AWS connection.
+    """
+    utils.pr_yellow('\nDelete Fabric Cloud Router to AWS Connection')
+    time.sleep(20)
+    connection_management.delete_connection(fcr2aws)
+
+    """
+    Deletes a Fabric Cloud Router (FCR) with the specified UUID.
+    """
+    utils.pr_yellow('\nDelete Fabric Cloud Router')
+    time.sleep(20)
+    cloud_router_management.delete_fcr(fcr_uuid)