Merge pull request #293849 from spelluru/relayqs0130

Fixed few obvious issues, but couldn't complete testing

Author: denrea

articles/azure-relay/includes/relay-hybrid-connections-websocket-requests-Python-get-started-client.md

@@ -6,92 +6,47 @@ ms.date: 05/16/2024
 ms.author: samurp
 ---
 
-### Create a Python Script
-
-If you disabled the "Requires Client Authorization" option when creating the Relay,
-you can send requests to the Hybrid Connections URL with any browser. For accessing
-protected endpoints, you need to create and pass a SAS Token, which is shown here.
-
-Here's a simple Python script that demonstrates sending requests to 
-a Hybrid Connections URL with SAS Tokens utilizing WebSockets. 
-
-### Dependencies
-
-1. Install the following Python libraries using pip before running the client application
-
-	`asyncio`, `json`, `logging`, `websockets`
-
-	These libraries can be installed using the following command:
-
-	```bash
-	pip install <package name>
-	```
-2. Generate a `config.json` file to store your connection details
-
-    ```json
-	{
-    "namespace": "HYBRID_CONNECTION_NAMESPACE",
-    "path": "HYBRID_CONNECTION_ENTITY_NAME",
-    "keyrule": "SHARED_ACCESS_KEY_NAME",
-    "key": "SHARED_ACCESS_PRIMARY_KEY"
-    }
-    ```
-	Replace the placeholders in brackets with the values you obtained when you created the hybrid connection.
-
-    - `namespace` - The Relay namespace. Be sure to use the fully qualified namespace name; for example, `{namespace}.servicebus.windows.net`.
-    - `path` - The name of the hybrid connection.
-    - `keyrule` - Name of your Shared Access Policies key, which is `RootManageSharedAccessKey` by default.
-    - `key` -   The primary key of the namespace you saved earlier.
-
-3. Generate a helper function file for helper functions
-
-	The following file is used as `relaylib.py` and have helper functions for WebSocket URL generation and SAS tokens
-
-    [!INCLUDE [relay-python-helper-functions](relay-python-helper-functions.md)]
-
 ### Write some code to send messages
 
 1. Ensure your dependency `config.json` and `relaylib.py` are available in your path 
-
-
 2. Here's what your `sender.py` file should look like:
 
     ```python
-	import asyncio
-	import json
-	import logging
-	import relaylib
-	import websockets
-
-	async def run_application(message, config):
-		service_namespace = config["namespace"]
-		entity_path = config["path"]
-		sas_key_name = config["keyrule"]
-		sas_key = config["key"]
-		service_namespace += ".servicebus.windows.net"
-
-		# Configure logging
-		logging.basicConfig(level=logging.DEBUG)  # Enable debug logging
-
-		token = relaylib.createSasToken(service_namespace, entity_path, sas_key_name, sas_key)
-		logging.debug("Token: %s", token)
-		wss_uri = relaylib.createListenUrl(service_namespace, entity_path, token)
-		logging.debug("WssURI: %s", wss_uri)
-
-		try:
-			async with websockets.connect(wss_uri) as websocket:
-				logging.info("Sending message to Azure Relay WebSocket...")
-				await websocket.send(json.dumps({"message": message}))
-				logging.info("Message sent: %s", message)
-		except Exception as e:
-			logging.error("An error occurred: %s", str(e))
-
-	if __name__ == "__main__":
-		# Load configuration from JSON file
-		with open("config.json") as config_file:
-			config = json.load(config_file)
-
-		asyncio.run(run_application("This is a message to Azure Relay Hybrid Connections!", config))
+    import asyncio
+    import json
+    import logging
+    import relaylib
+    import websockets
+
+    async def run_application(message, config):
+        service_namespace = config["namespace"]
+        entity_path = config["path"]
+        sas_key_name = config["keyrule"]
+        sas_key = config["key"]
+        service_namespace += ".servicebus.windows.net"
+
+        # Configure logging
+        logging.basicConfig(level=logging.DEBUG)  # Enable debug logging
+
+        token = relaylib.createSasToken(service_namespace, entity_path, sas_key_name, sas_key)
+        logging.debug("Token: %s", token)
+        wss_uri = relaylib.createSendUrl(service_namespace, entity_path, token)
+        logging.debug("WssURI: %s", wss_uri)
+
+        try:
+            async with websockets.connect(wss_uri) as websocket:
+                logging.info("Sending message to Azure Relay WebSocket...")
+                await websocket.send(json.dumps({"message": message}))
+                logging.info("Message sent: %s", message)
+        except Exception as e:
+            logging.error("An error occurred: %s", str(e))
+
+    if __name__ == "__main__":
+        # Load configuration from JSON file
+        with open("config.json") as config_file:
+            config = json.load(config_file)
+
+        asyncio.run(run_application("This is a message to Azure Relay Hybrid Connections!", config))
     ```
 
 > [!NOTE]

articles/azure-relay/includes/relay-hybrid-connections-websocket-requests-Python-get-started-server.md

@@ -29,11 +29,11 @@ a Hybrid Connections URL with SAS Tokens utilizing WebSockets.
 2. Generate a `config.json` file to store your connection details
 
     ```json
-	{
-    "namespace": "HYBRID_CONNECTION_NAMESPACE",
-    "path": "HYBRID_CONNECTION_ENTITY_NAME",
-    "keyrule": "SHARED_ACCESS_KEY_NAME",
-    "key": "SHARED_ACCESS_PRIMARY_KEY"
+    {
+        "namespace": "HYBRID_CONNECTION_NAMESPACE",
+        "path": "HYBRID_CONNECTION_ENTITY_NAME",
+        "keyrule": "SHARED_ACCESS_KEY_NAME",
+        "key": "SHARED_ACCESS_PRIMARY_KEY"
 	}
 	```
 	Replace the placeholders in brackets with the values you obtained when you created the hybrid connection.
@@ -42,54 +42,51 @@ a Hybrid Connections URL with SAS Tokens utilizing WebSockets.
 	- `path` - The name of the hybrid connection.
 	- `keyrule` - Name of your Shared Access Policies key, which is `RootManageSharedAccessKey` by default.
 	- `key` -   The primary key of the namespace you saved earlier.
-
 3. Generate a helper function file for helper functions
 
 	The following file is used as `relaylib.py` and have helper functions for WebSocket URL generation and SAS tokens
 
     [!INCLUDE [relay-python-helper-functions](relay-python-helper-functions.md)]
 
-### Write some code to send messages
+### Write some code to receive messages
 
 1. Ensure your dependency `config.json` and `relaylib.py` are available in your path 
-
-
 2. Here's what your `listener.py` file should look like:
 
     ```python
-	import asyncio
-	import json
-	import logging
-	import relaylib
-	import websockets
-
-	async def run_application(config):
-	    serviceNamespace = config["namespace"]
-	    entityPath = config["path"]
-	    sasKeyName = config["keyrule"]
-	    sasKey = config["key"]
-	    serviceNamespace += ".servicebus.windows.net"
-	    # Configure logging
-	    logging.basicConfig(level=logging.INFO)  # Enable DEBUG/INFO logging as appropriate
-
-	    try:
-	        logging.debug("Generating SAS Token for: %s", serviceNamespace)
-		token = relaylib.createSasToken(serviceNamespace, entityPath, sasKeyName, sasKey)
-		logging.debug("Generating WebSocket URI")
-		wssUri = relaylib.createListenUrl(serviceNamespace, entityPath, token)
-		async with websockets.connect(wssUri) as websocket:
-		    logging.info("Listening for messages on Azure Relay WebSocket...")
-		    while True:
-			message = await websocket.recv()
-			logging.info("Received message: %s", message)
-		    except KeyboardInterrupt:
-			logging.info("Exiting listener.")
-
-	if __name__ == "__main__":
-	    # Load configuration from JSON file
-	    with open("config.json") as config_file:
+    import asyncio
+    import json
+    import logging
+    import relaylib
+    import websockets
+
+    async def run_application(config):
+        serviceNamespace = config["namespace"]
+        entityPath = config["path"]
+        sasKeyName = config["keyrule"]
+        sasKey = config["key"]
+        serviceNamespace += ".servicebus.windows.net"
+        # Configure logging
+        logging.basicConfig(level=logging.INFO)  # Enable DEBUG/INFO logging as appropriate
+
+        try:
+            logging.debug("Generating SAS Token for: %s", serviceNamespace)
+            token = relaylib.createSasToken(serviceNamespace, entityPath, sasKeyName, sasKey)
+            logging.debug("Generating WebSocket URI")
+            wssUri = relaylib.createListenUrl(serviceNamespace, entityPath, token)
+            async with websockets.connect(wssUri) as websocket:
+                logging.info("Listening for messages on Azure Relay WebSocket...")
+                while True:
+                    message = await websocket.recv()
+                    logging.info("Received message: %s", message)
+        except KeyboardInterrupt:
+            logging.info("Exiting listener.")
+
+        if __name__ == "__main__":
+            # Load configuration from JSON file
+            with open("config.json") as config_file:
             config = json.load(config_file)
 
-	    asyncio.run(run_application(config))
+        asyncio.run(run_application(config))
     ```
 

articles/azure-relay/includes/relay-python-helper-functions.md

@@ -50,7 +50,7 @@ def createListenUrl(serviceNamespace, entityPath, token = None):
 def createSendUrl(serviceNamespace, entityPath, token = None):
     url = 'wss://' + serviceNamespace + '/$hc/' + entityPath + '?sb-hc-action=connect&sb-hc-id=123456'
     if token is not None:
-	url = url + '&sb-hc-token=' + urllib.parse.quote(token)
+        url = url + '&sb-hc-token=' + urllib.parse.quote(token)
     return url
 
 # Function which creates the Service Bus SAS token. 
@@ -72,7 +72,7 @@ def createSasToken(serviceNamespace, entityPath, sasKeyName, sasKey):
     hashBytes = hmac_sha256(sasKeyBytes, plainSignatureBytes)
     base64HashValue = base64.b64encode(hashBytes)
 
-     # Construct the SAS token string
+    # Construct the SAS token string
     token = "SharedAccessSignature sr=" + encodedResourceUri + "&sig=" +  urllib.parse.quote(base64HashValue) + "&se=" + str(expiryInSeconds) + "&skn=" + sasKeyName
     return token
  ```

articles/azure-relay/relay-hybrid-connections-python-get-started.md

@@ -2,7 +2,7 @@
 title: Azure Relay Hybrid Connections - WebSocket requests in Python
 description: Write a Python console application for Azure Relay Hybrid Connections WebSocket requests.
 ms.topic: tutorial
-ms.date: 05/16/2024
+ms.date: 01/30/2025
 ms.custom: devx-track-Python, mode-ui, mode-api, devx-track-extended-Python
 ---
 
@@ -23,7 +23,7 @@ In this quickstart, you take the following steps:
 1. Execute the server (listener) script and optionally the client (sender) script.
 
 ## Prerequisites
-- [Python](https://www.Python.com/en/). Ensure that you're running Python 3.10+
+- [Python](https://www.python.org/). Ensure that you're running Python 3.10+
 - An Azure subscription. If you don't have one, [create a free account](https://azure.microsoft.com/free/) before you begin.
 
 ## Create a namespace using the Azure portal
@@ -32,9 +32,6 @@ In this quickstart, you take the following steps:
 ## Create a hybrid connection using the Azure portal
 [!INCLUDE [relay-create-hybrid-connection-portal](./includes/relay-create-hybrid-connection-portal.md)]
 
-## Develop helper functions
-[!INCLUDE [relay-python-helper-functions](./includes/relay-python-helper-functions.md)]
-
 ## Create a server application (listener)
 To listen and receive messages from the Relay, write a Python WebSocket Server script.