Here's a quick run at a Python Relay HybridConnection Listener which can process HTTP Requests. I'm not accustomed to working in Python so things like error handling and class/module encapsulation are lacking.

Program.py

import asyncio
import json
import relaylib
import urllib
import websockets

async def run_application():
    serviceNamespace = 'contoso-sb.servicebus.windows.net'
    entityPath = 'unauthenticated'
    sasKeyName = 'RootManageSharedAccessKey'
    sasKey = 'GgRm12TgutmThtiRHo6DZqUpeZMbjQh0fNytng+oAcM='

    token = relaylib.createSasToken(serviceNamespace, entityPath, sasKeyName, sasKey)
    wssUri = relaylib.createListenUrl(serviceNamespace, entityPath, token)

    async with websockets.connect(wssUri) as websocket:
        keepGoing = True
        while keepGoing:
            commandStr = await websocket.recv()

            command = json.loads(commandStr)
            request = command['request']
            operationwebsocket = websocket
            rendezvouswebsocket = None
            if request is not None:
                print("\nRequest:\n{}".format(commandStr))
                if 'method' not in request:
                    print('Need to rendezvous to accept the actual request')
                    rendezvouswebsocket = await websockets.connect(request['address'])
                    operationwebsocket = rendezvouswebsocket
                    commandStr = await rendezvouswebsocket.recv()
                    print(commandStr)
                    command = json.loads(commandStr)
                    request = command['request']
                
                if request['body']:
                    #request has a body, read it from the websocket from which the request was read
                    requestBody = await operationwebsocket.recv()
                    print('RequestBody is {0} bytes'.format(len(requestBody)))

                response = {}
                response['requestId'] = request['id']
                response['body'] = True
                response['statusCode'] = 200
                response['responseHeaders'] = {}
                response['responseHeaders']['Content-Type'] = 'text/html'
                responseStr = json.dumps({'response' : response })
                print("\nResponse:\n{}".format(responseStr))
                await operationwebsocket.send(responseStr)

                #Response body, if present, must be binary(bytes)
                #TODO: If the response body is > 64kb it must be sent over the rendezvouswebsocket (which may need to be created for the response)
                responseBodyStr = "<html><body><H1>Hello World</H1><p>From a Python Listener</p><body></html>"
                print("ResponseBody:{}".format(responseBodyStr))
                responseBodyBytes = responseBodyStr.encode('utf-8')
                await operationwebsocket.send(responseBodyBytes)

                if rendezvouswebsocket is not None:
                    await rendezvouswebsocket.close()
            
asyncio.get_event_loop().run_until_complete(run_application())

relaylib.py

import base64
import hashlib
import hmac
import math
import time
import urllib

def hmac_sha256(key, msg):
    hash_obj = hmac.new(key=key, msg=msg, digestmod=hashlib._hashlib.openssl_sha256)
    return hash_obj.digest()

def createListenUrl(serviceNamespace, entityPath, token = None):
    url = 'wss://' + serviceNamespace + '/$hc/' + entityPath + '?sb-hc-action=listen'
    if token is not None:
        url = url + '&sb-hc-token=' + urllib.parse.quote(token)
    return url

# Function which creates the Service Bus SAS token. 
def createSasToken(serviceNamespace, entityPath, sasKeyName, sasKey):
    uri = "http://" + serviceNamespace + "/" + entityPath
    encodedResourceUri = urllib.parse.quote(uri, safe = '')
        
    tokenValidTimeInSeconds = 60 * 60 # One Hour
    unixSeconds = math.floor(time.time())
    expiryInSeconds = unixSeconds + tokenValidTimeInSeconds

    plainSignature = encodedResourceUri + "\n" + str(expiryInSeconds)
    sasKeyBytes = sasKey.encode("utf-8")
    plainSignatureBytes = plainSignature.encode("utf-8")
    hashBytes = hmac_sha256(sasKeyBytes, plainSignatureBytes)
    base64HashValue = base64.b64encode(hashBytes)

    token = "SharedAccessSignature sr=" + encodedResourceUri + "&sig=" +  urllib.parse.quote(base64HashValue) + "&se=" + str(expiryInSeconds) + "&skn=" + sasKeyName
    return token

Python Example #28

Description

andrewkittredgeopenedon May 18, 2018

Activity

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

andrewkittredge
openedon May 18, 2018