diff --git a/examples/services/fabricv4/__init__.py b/examples/services/fabricv4/__init__.py new file mode 100644 index 00000000..906be894 --- /dev/null +++ b/examples/services/fabricv4/__init__.py @@ -0,0 +1 @@ +__all__ = ['cloud_router','connections','utils','oauth2'] diff --git a/examples/services/fabricv4/cloud_router/__init__.py b/examples/services/fabricv4/cloud_router/__init__.py new file mode 100644 index 00000000..e3d57c80 --- /dev/null +++ b/examples/services/fabricv4/cloud_router/__init__.py @@ -0,0 +1 @@ +__all__ = ['cloud_router','cloud_router_management'] diff --git a/examples/services/fabricv4/cloud_router/cloud_router.py b/examples/services/fabricv4/cloud_router/cloud_router.py new file mode 100644 index 00000000..f8f3ca77 --- /dev/null +++ b/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": [ + "test@test.com" + ] + } + ] + ) + 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) diff --git a/examples/services/fabricv4/cloud_router/cloud_router_management.py b/examples/services/fabricv4/cloud_router/cloud_router_management.py new file mode 100644 index 00000000..9c6d8070 --- /dev/null +++ b/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') diff --git a/examples/services/fabricv4/connections/__init__.py b/examples/services/fabricv4/connections/__init__.py new file mode 100644 index 00000000..7fe4d98c --- /dev/null +++ b/examples/services/fabricv4/connections/__init__.py @@ -0,0 +1 @@ +__all__ = ['connection_management','fcr_2_aws_connection','fcr_2_port_connection','fcr_2_azure_connection'] diff --git a/examples/services/fabricv4/connections/connection_management.py b/examples/services/fabricv4/connections/connection_management.py new file mode 100644 index 00000000..293ffbe8 --- /dev/null +++ b/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') diff --git a/examples/services/fabricv4/connections/fcr_2_aws_connection.py b/examples/services/fabricv4/connections/fcr_2_aws_connection.py new file mode 100644 index 00000000..fa4636cd --- /dev/null +++ b/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": [ + "test@test.com" + ] + } + ] + ) + 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": [ + "test@test.com" + ] + } + ] + ) + 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) diff --git a/examples/services/fabricv4/connections/fcr_2_azure_connection.py b/examples/services/fabricv4/connections/fcr_2_azure_connection.py new file mode 100644 index 00000000..6b2d8ca2 --- /dev/null +++ b/examples/services/fabricv4/connections/fcr_2_azure_connection.py @@ -0,0 +1,110 @@ +import time +import os + +from equinix.services.fabricv4 import CloudRouterPostRequest, ConnectionPostRequest, RoutingProtocolDirectType +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="fcrtoazurefcr_01", + location={"metro_code": "DC"}, + package={"code": "STANDARD"}, + order={"purchase_order_number": "1-1453534"}, + project={"project_id": "12354863434345"}, + account={"account_number": 123456}, + notifications=[ + { + "type": "ALL", + "emails": [ + "test@test.com" + ] + } + ] + ) + fcr_uuid = cloud_router_management.create_fcr(fcr_request) + + """ + Create a Fabric Cloud Router (FCR) to Azure Connection. + """ + utils.pr_yellow('\nCreate Fabric Cloud Router to Azure Connection') + fcr2azure_request = ConnectionPostRequest( + type="IP_VC", + name="fcr2azure_conn_python_01", + bandwidth=50, + aSide={ + "accessPoint": { + "type": "CLOUD_ROUTER", + "router": { + "uuid": fcr_uuid + } + } + }, + zSide={ + "accessPoint": { + "type": "SP", + "profile": { + "type": "L2_PROFILE", + "uuid": "xxxx22-xxxx-xxxx-xxxx" + }, + "authenticationKey": os.getenv("AZURE_AUTH_KEY"), + "location": { + "metroCode": "DC" + }, + "peeringType": "PRIVATE" + } + }, + order={"purchaseOrderNumber": "1-129105284100"}, + project={"projectId": "124345345345345"}, + notifications=[ + { + "type": "ALL", + "emails": [ + "panthersfcr@test.com" + ] + } + ] + ) + fcr2azure = connection_management.create_fcr_connection(fcr_uuid, fcr2azure_request) + + """ + Configures a routing protocol for a Fabric Cloud Router (FCR) to Azure 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(fcr2azure, routing_protocol_request) + + """ + Retrieves the connection details for a Fabric Cloud Router (FCR) to Azure connection by its UUID. + This method is primarily used to fetch detailed information about a specific connection between + a Fabric Cloud Router and Azure, using the connection's unique identifier (UUID). + """ + utils.pr_yellow('\nGet FCR2Azure Connection Details by UUID') + time.sleep(120) + connection_management.get_connection_details_by_uuid(fcr2azure) + + """ + Deletes a Fabric Cloud Router (FCR) to Azure connection. + """ + utils.pr_yellow('\nDelete Fabric Cloud Router to Azure Connection') + time.sleep(20) + connection_management.delete_connection(fcr2azure) + + """ + 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) diff --git a/examples/services/fabricv4/connections/fcr_2_port_connection.py b/examples/services/fabricv4/connections/fcr_2_port_connection.py new file mode 100644 index 00000000..a1e0a9b5 --- /dev/null +++ b/examples/services/fabricv4/connections/fcr_2_port_connection.py @@ -0,0 +1,129 @@ +import time + +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="fcrtoportfcr_01", + location={"metro_code": "SV"}, + package={"code": "STANDARD"}, + order={"purchase_order_number": "1-1453534"}, + project={"project_id": "1232432542545435"}, + account={"account_number": 123456}, + notifications=[ + { + "type": "ALL", + "emails": [ + "test@test.com" + ] + } + ] + ) + fcr_uuid = cloud_router_management.create_fcr(fcr_request) + + """ + Create a Fabric Cloud Router (FCR) to Colo Port Connection. + """ + utils.pr_yellow('\nCreate Fabric Cloud Router to Colo Connection') + fcr2colo_request = ConnectionPostRequest( + type="IP_VC", + name="fcr2port_conn_python_01", + bandwidth=10, + a_side={ + "accessPoint": { + "type": "CLOUD_ROUTER", + "router": { + "uuid": fcr_uuid + } + } + }, + z_side={ + "accessPoint": { + "type": "COLO", + "port": { + "uuid": "xxxx22-xxxx-xxxx-xxxx" + }, + "linkProtocol": { + "type": "DOT1Q", + "vlanTag": 3200 + } + } + }, + project={"project_id": "1232432542545435"}, + notifications=[ + { + "type": "ALL", + "emails": [ + "test@test.com" + ] + } + ] + ) + fcr2colo = connection_management.create_fcr_connection(fcr_uuid, fcr2colo_request) + + """ + Configures a routing protocol for a Fabric Cloud Router (FCR) to Port 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(fcr2colo, routing_protocol_request) + + """ + Retrieves the connection details for a Fabric Cloud Router (FCR) to Port connection by its UUID. + This method is primarily used to fetch detailed information about a specific connection between + a Fabric Cloud Router and Port, using the connection's unique identifier (UUID). + """ + utils.pr_yellow('\nGet FCR2Port Connection Details by UUID') + connection_management.get_connection_details_by_uuid(fcr2colo) + + """ + Updates the name details of a connection using the provided Connection UUID. + """ + utils.pr_yellow('\nUpdate Name Details Using Connection_UUID') + port_conn_name_update = [ConnectionChangeOperation( + op="replace", + path="/name", + value="fcr2PortUpdate" + ) + ] + connection_management.update_connection_details_by_uuid(fcr2colo,port_conn_name_update) + + """ + Updates the bandwidth details of a connection using the provided Connection UUID. + """ + utils.pr_yellow('\nUpdate Bandwidth Details Using Connection_UUID') + port_conn_bandwidth_update = [ConnectionChangeOperation( + op="replace", + path="/bandwidth", + value=50 + ) + ] + connection_management.update_connection_details_by_uuid(fcr2colo,port_conn_bandwidth_update) + + """ + Deletes a Fabric Cloud Router (FCR) to Port Colo connection. + """ + utils.pr_yellow('\nDelete Fabric Cloud Router to Colo Connection') + time.sleep(60) + connection_management.delete_connection(fcr2colo) + + """ + Deletes a Fabric Cloud Router (FCR) with the specified UUID. + """ + utils.pr_yellow('\nDelete Fabric Cloud Router') + cloud_router_management.delete_fcr(fcr_uuid) diff --git a/examples/services/fabricv4/oauth2/__init__.py b/examples/services/fabricv4/oauth2/__init__.py new file mode 100644 index 00000000..4322b269 --- /dev/null +++ b/examples/services/fabricv4/oauth2/__init__.py @@ -0,0 +1 @@ +__all__ = ['configure_client_credentials'] diff --git a/examples/services/fabricv4/oauth2/configure_client_credentials.py b/examples/services/fabricv4/oauth2/configure_client_credentials.py new file mode 100644 index 00000000..2650cccc --- /dev/null +++ b/examples/services/fabricv4/oauth2/configure_client_credentials.py @@ -0,0 +1,43 @@ + +import os +import json + +from rauth import OAuth2Service +from equinix.services import fabricv4 + + +def get_equinix_fabric_client(): + """ + Initializes and returns an Equinix Fabric API client using OAuth2 authentication. + + This method is designed to authenticate with the Equinix Fabric API using OAuth2 + client credentials flow. It retrieves the client ID and client secret from the + environment variables `EQUINIX_API_CLIENTID` and `EQUINIX_API_CLIENTSECRET`. These + credentials are then used to obtain an OAuth2 access token, which is subsequently + used to configure the Equinix Fabric API client. + """ + + client_id = os.getenv("EQUINIX_API_CLIENT_ID") + client_secret = os.getenv("EQUINIX_API_CLIENT_SECRET") + + oauth2_service = OAuth2Service( + name="Fabricv4", + client_id=client_id, + client_secret=client_secret, + access_token_url="https://api.equinix.com/oauth2/v1/token", + authorize_url="https://api.equinix.com/oauth2/v1/token", + base_url="https://api.equinix.com/", + ) + + data = { + 'code': 'Fabricv4', # specific to my app + 'grant_type': 'client_credentials', # generally required! + } + + oauth2_session = oauth2_service.get_auth_session(data=data, decoder=json.loads) + conf = fabricv4.Configuration( + host="https://api.equinix.com/", + ) + + conf.access_token = oauth2_session.access_token + return fabricv4.ApiClient(conf) diff --git a/examples/services/fabricv4/utils/utils.py b/examples/services/fabricv4/utils/utils.py new file mode 100644 index 00000000..455bfa8d --- /dev/null +++ b/examples/services/fabricv4/utils/utils.py @@ -0,0 +1,35 @@ +# Utility functions. + +from datetime import datetime +from enum import Enum + + +def pr_cyan(skk): + """Prints the given string in cyan color.""" + print("\033[96m {}\033[00m".format(skk)) + + +def pr_yellow(skk): + """Prints the given string in yellow color.""" + print("\033[93m {}\033[00m".format(skk)) + + +def pr_purple(skk): + """Prints the given string in purple color.""" + print("\033[95m {}\033[00m".format(skk)) + + +def custom_serializer(obj): + """ + Custom JSON serializer to handle various object types. + - Handles Enums by returning their value. + - Converts datetime objects to ISO format. + - Converts objects with `__dict__` attribute to dictionary representation. + """ + if isinstance(obj, Enum): + return obj.value + if isinstance(obj, datetime): + return obj.isoformat() + if hasattr(obj, '__dict__'): + return obj.__dict__ + return str(obj)