Skip to content

Azure SignalR Service

The plugin can connect to the an Azure SignalR Service with its default authenticator.

When used with Azure Functions Invoke and other client to server messaging can be done through Azure Functions (HTTP requests). See https://docs.microsoft.com/en-us/azure/azure-signalr/signalr-concept-serverless-development-config#sending-messages-from-a-client-to-the-service

Azure SignalR Service with Azure Functions

When a /negotiate endpoint is defined in Azure Functions the SignalR client must connect to the Azure Functions service. 

1
2
3
4
5
6
7
8
var conn = new HubConnection(new Uri("http://localhost:7071/api/"), new JsonProtocol(new LitJsonEncoder()));

conn.On<string>("newMessage", msg =>
{
    Debug.Log(msg);
});

conn.StartConnect();

When Azure SignalR Service is used with Functions, negotiating the protocol starts by getting the first connection information from Functions that contains both an access token and a URL to redirect. The client will use these to connect to the SignalR Service.

If that negotiate response includes tokenLifetimeSeconds, the client can ask the original hub for a new access token before the current one expires. The refresh request stays on the URI passed to HubConnection, and a returned accessToken replaces the token used for the service. See Authentication Refresh.

Azure SignalR Service with Azure Functions Authorization

To send x-ms-client-principal-id header for PlayFab and x-functions-key for Azure Functions key the default authenticator can be modified to append these headers in PrepareRequest:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
using System;

using Best.SignalR;

namespace Best.SignalR.Authentication
{
    public sealed class AccessTokenAuthenticatorWithAzureFunctionAuthorization : IAuthenticationProvider
    {
        /// <summary>
        /// No pre-auth step required for this type of authentication
        /// </summary>
        public bool IsPreAuthRequired { get { return false; } }

    #pragma warning disable 0067
        /// <summary>
        /// Not used event as IsPreAuthRequired is false
        /// </summary>
        public event OnAuthenticationSuccededDelegate OnAuthenticationSucceded;

        /// <summary>
        /// Not used event as IsPreAuthRequired is false
        /// </summary>
        public event OnAuthenticationFailedDelegate OnAuthenticationFailed;

    #pragma warning restore 0067

        private HubConnection _connection;
        private string _playFabId;
        private string _clientPrincipalId;

        public AccessTokenAuthenticatorWithAzureFunctionAuthorization(HubConnection connection, string playFabId, string clientPrincipalId)
        {
            this._connection = connection;
            this._playFabId = playFabId;
            this._clientPrincipalId = clientPrincipalId;
        }

        /// <summary>
        /// Not used as IsPreAuthRequired is false
        /// </summary>
        public void StartAuthentication() { }

        /// <summary>
        /// Prepares the request by adding two headers to it
        /// </summary>
        public void PrepareRequest(Best.HTTP.HTTPRequest request)
        {
            // Add Authorization header to http requests, add access_token param to the uri otherwise
            if (Best.HTTP.Hosts.Connections.HTTPProtocolFactory.GetProtocolFromUri(request.CurrentUri) == Best.HTTP.Hosts.Connections.SupportedProtocols.HTTP)
            {
                if (this._connection.NegotiationResult != null)
                    request.SetHeader("Authorization", "Bearer " + this._connection.NegotiationResult.AccessToken);

                if (!string.IsNullOrEmpty(this._playFabId))
                    request.SetHeader("x-ms-client-principal-id", this._playFabId);

                if (!string.IsNullOrEmpty(this._clientPrincipalId))
                    request.SetHeader("x-functions-key", this._clientPrincipalId);
            }
            else
                if (Best.HTTP.Hosts.Connections.HTTPProtocolFactory.GetProtocolFromUri(request.Uri) != Best.HTTP.Hosts.Connections.SupportedProtocols.WebSocket)
                    request.Uri = PrepareUriImpl(request.Uri);
        }

        public Uri PrepareUri(Uri uri)
        {
            if (this._connection.NegotiationResult == null)
                return uri;

            if (uri.Query.StartsWith("??"))
            {
                UriBuilder builder = new UriBuilder(uri);
                builder.Query = builder.Query.Substring(2);

                return builder.Uri;
            }

            if (Best.HTTP.Hosts.Connections.HTTPProtocolFactory.GetProtocolFromUri(uri) == Best.HTTP.Hosts.Connections.SupportedProtocols.WebSocket)
                uri = PrepareUriImpl(uri);

            return uri;

        }

        private Uri PrepareUriImpl(Uri uri)
        {
            if (this._connection.NegotiationResult != null && !string.IsNullOrEmpty(this._connection.NegotiationResult.AccessToken))
            {
                string query = string.IsNullOrEmpty(uri.Query) ? "" : uri.Query + "&";
                UriBuilder uriBuilder = new UriBuilder(uri.Scheme, uri.Host, uri.Port, uri.AbsolutePath, query + "access_token=" + this._connection.NegotiationResult.AccessToken);
                return uriBuilder.Uri;
            }

            return uri;
        }

        public void Cancel() { }
    }
}

And can be used like this: 

1
2
var hub = new HubConnection(URL, protocol);
hub.AuthenticationProvider = new AccessTokenAuthenticatorWithAzureFunctionAuthorization(hub, "<Play Fab ID>", "<Azure Functions Key>");

Comments