#530

pending completion

Build # #530

Build Type

push

github-actions

Committed by

web-flow

Commit Message

<a href="https://github.com/Badgerati/Pode/commit/<a class=hub.com/Badgerati/Pode/commit/def7c721613f676101687c241956c4ab0a839eaa">def7c7216<a href="https://github.com/Badgerati/Pode/commit/def7c721613f676101687c241956c4ab0a839eaa">">Merge </a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/<a class="double-link" href="https://github.com/Badgerati/Pode/commit/cef073ea73f4d2891f2223e4bcb2b0f190c75972">cef073ea7</a>">cef073ea7</a><a href="https://github.com/Badgerati/Pode/commit/def7c721613f676101687c241956c4ab0a839eaa"> into 6575482e6">6575482e6</a>

Run Details

411 of 411 new or added lines in 12 files covered. (100.0%)

2343 of 5094 relevant lines covered (46.0%)

1.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Private/SignalServer.ps1

function Start-PodeSignalServer
{
    # setup the callback for sockets
    $PodeContext.Server.WebSockets.Ssl.Callback = Get-PodeSocketCertifcateCallback

    # work out which endpoints to listen on
    $endpoints = @()
    @(Get-PodeEndpoints -Type Ws) | ForEach-Object {
        # get the ip address
        $_ip = [string]($_.Address)
        $_ip = (Get-PodeIPAddressesForHostname -Hostname $_ip -Type All | Select-Object -First 1)
        $_ip = (Get-PodeIPAddress $_ip)

        # add endpoint to list
        $endpoints += @{
            Address = $_ip
            Port = $_.Port
            Certificate = $_.Certificate.Raw
            HostName = $_.Url
        }
    }

    try
    {
        # register endpoints on the listener
        $endpoints | ForEach-Object {
            $PodeContext.Server.WebSockets.Listeners += (Initialize-PodeSocketListenerEndpoint `
                -Type WebSockets `
                -Address $_.Address `
                -Port $_.Port `
                -Certificate $_.Certificate)
        }
    }
    catch {
        $_ | Write-PodeErrorLog
        $_.Exception | Write-PodeErrorLog -CheckInnerException
        Close-PodeSocketListener -Type WebSockets
        throw $_.Exception
    }

    # script for listening out for incoming requests
    $listenScript = {
        param (
            [Parameter(Mandatory=$true)]
            [int]
            $ThreadId
        )

        try
        {
            Start-PodeSocketListener -Listeners $PodeContext.Server.WebSockets.Listeners

            [System.Threading.Thread]::CurrentThread.IsBackground = $true
            [System.Threading.Thread]::CurrentThread.Priority = [System.Threading.ThreadPriority]::Lowest

            while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)
            {
                Wait-PodeTask ([System.Threading.Tasks.Task]::Delay(60))
            }
        }
        catch [System.OperationCanceledException] {}
        catch {
            $_ | Write-PodeErrorLog
            $_.Exception | Write-PodeErrorLog -CheckInnerException
            throw $_.Exception
        }
    }

    # start the runspace for listening on x-number of threads
    1..$PodeContext.Threads.Web | ForEach-Object {
        Add-PodeRunspace -Type 'Signals' -ScriptBlock $listenScript `
            -Parameters @{ 'ThreadId' = $_ }
    }

    # script to write messages back to the client(s)
    $signalScript = {
        try {
            [System.Threading.Thread]::CurrentThread.IsBackground = $true
            [System.Threading.Thread]::CurrentThread.Priority = [System.Threading.ThreadPriority]::Lowest

            while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)
            {
                Wait-PodeTask ([System.Threading.Tasks.Task]::Delay(100))

                # check if we have any messages to send
                $message = $null
                if (!$PodeContext.Server.WebSockets.Queues.Messages.TryDequeue([ref]$message)) {
                    $message = $null
                }

                if ($null -eq $message) {
                    continue
                }

                # get the sockets for the message
                $sockets = @()

                # by clientId
                if (![string]::IsNullOrWhiteSpace($message.ClientId)) {
                    $sockets = @($PodeContext.Server.WebSockets.Queues.Sockets[$message.ClientId])
                }
                else {
                    $sockets = @($PodeContext.Server.WebSockets.Queues.Sockets.Values)

                    # by path
                    if (![string]::IsNullOrWhiteSpace($message.Path)) {
                        $sockets = @(foreach ($socket in $sockets) {
                            if ($socket.Path -ieq $message.Path) {
                                $socket
                                break
                            }
                        })
                    }
                }

                # do nothing if no socket found
                if (($null -eq $sockets) -or ($sockets.Length -eq 0)) {
                    continue
                }

                # frame the message
                $buffer = [byte[]]@()
                $buffer += [byte]([byte]0x80 -bor [byte]1)

                $payload = $PodeContext.Server.Encoding.GetBytes($message.Value)
                if ($payload.Length -lt 126) {
                    $buffer += [byte]([byte]0x00 -bor [byte]$payload.Length)
                }
                elseif ($payload.Length -le [uint16]::MaxValue) {
                    $buffer += [byte]([byte]0x00 -bor [byte]126)
                }
                else {
                    $buffer += [byte]([byte]0x00 -bor [byte]127)
                }

                $buffer += $payload

                # send the message to all found sockets
                foreach ($socket in $sockets) {
                    try {
                        Wait-PodeTask -Task $socket.Stream.WriteAsync($buffer, 0, $buffer.Length)
                    }
                    catch {
                        $PodeContext.Server.WebSockets.Queues.Sockets.Remove($socket.ClientId) | Out-Null
                    }
                }
            }
        }
        catch [System.OperationCanceledException] {}
        catch {
            $_ | Write-PodeErrorLog
            $_.Exception | Write-PodeErrorLog -CheckInnerException
            throw $_.Exception
        }
    }

    Add-PodeRunspace -Type 'Signals' -ScriptBlock $signalScript

    # script to keep web server listening until cancelled
    $waitScript = {
        try {
            while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested) {
                Start-Sleep -Seconds 1
            }
        }
        catch [System.OperationCanceledException] {}
        catch {
            $_ | Write-PodeErrorLog
            $_.Exception | Write-PodeErrorLog -CheckInnerException
            throw $_.Exception
        }
        finally {
            Close-PodeSocketListener -Type WebSockets
        }
    }

    Add-PodeRunspace -Type 'Signals' -ScriptBlock $waitScript
    return @($endpoints.HostName)
}

function Invoke-PodeWebSocketHandler
{
    param(
        [Parameter(Mandatory)]
        [hashtable]
        $Context
    )

    try
    {
        # make the stream (use an ssl stream if we have a cert)
        $stream = [System.Net.Sockets.NetworkStream]::new($Context.Socket, $true)

        if ($null -ne $Context.Certificate) {
            try {
                $stream = [System.Net.Security.SslStream]::new($stream, $false, $PodeContext.Server.WebSockets.Ssl.Callback)
                $stream.AuthenticateAsServer($Context.Certificate, $false, $PodeContext.Server.WebSockets.Ssl.Protocols, $false)
            }
            catch {
                # immediately close http connections
                Close-PodeSocket -Socket $Context.Socket -Shutdown
                return
            }
        }

        # read the request headers - once again, I apologise profusely.
        try {
            $bytes = New-Object byte[] 0
            $Context.Socket.Receive($bytes) | Out-Null
        }
        catch {
            $err = [System.Net.Http.HttpRequestException]::new()
            $err.Data.Add('PodeStatusCode', 408)
            throw $err
        }

        $bytes = New-Object byte[] $Context.Socket.Available
        (Wait-PodeTask -Task $stream.ReadAsync($bytes, 0, $Context.Socket.Available)) | Out-Null
        $req_info = Get-PodeServerRequestDetails -Bytes $bytes -Protocol $Context.Protocol

        # if the method is not a GET, close immediately
        if ($req_info.Method -ine 'GET') {
            Close-PodeSocket -Socket $Context.Socket -Shutdown
            return
        }
    }
    catch [System.OperationCanceledException] {}
    catch [System.Net.Http.HttpRequestException] {
        $code = [int]($_.Exception.Data['PodeStatusCode'])
        if ($code -le 0) {
            $code = 400
        }

        Set-PodeResponseStatus -Code $code -Exception $_
    }
    catch {
        $_ | Write-PodeErrorLog
        $_.Exception | Write-PodeErrorLog -CheckInnerException
        Set-PodeResponseStatus -Code 500 -Exception $_
    }

    try {
        # get the path, and generate a clientId
        $path = $req_info.Uri.AbsolutePath
        $clientId = New-PodeGuid -Secure

        # send back headers to upgrade the client to a websocket
        $magicGuid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
        $secSocketKey = $req_info.Headers['Sec-WebSocket-Key'].Trim()

        $resHeaders = @{
            'Connection' = 'Upgrade'
            'Upgrade' = 'websocket'
            'Sec-WebSocket-Accept' = Invoke-PodeSHA1Hash -Value "$($secSocketKey)$($magicGuid)"
            'X-Pode-ClientId' = $clientId
        }

        # write the response line
        $protocol = $req_info.Protocol
        if ([string]::IsNullOrWhiteSpace($protocol)) {
            $protocol = 'HTTP/1.1'
        }

        $newLine = "`r`n"
        $res_msg = "$($protocol) 101 Switching Protocols$($newLine)"

        # write the response headers
        foreach ($key in $resHeaders.Keys) {
            $res_msg += "$($key): $($resHeaders[$key])$($newLine)"
        }

        $res_msg += $newLine

        # stream response output
        $buffer = $PodeContext.Server.Encoding.GetBytes($res_msg)
        Wait-PodeTask -Task $stream.WriteAsync($buffer, 0, $buffer.Length)

        # add the socket/stream to all sockets, and path sockets (and clientId)
        $PodeContext.Server.WebSockets.Queues.Sockets[$clientId] = @{
            Socket = $Context.Socket
            Stream = $stream
            Path = $path
            ClientId = $clientId
        }
    }
    catch [System.Management.Automation.MethodInvocationException] { }
}

1	function Start-PodeSignalServer
2	{
3	# setup the callback for sockets
4	$PodeContext.Server.WebSockets.Ssl.Callback = Get-PodeSocketCertifcateCallback	×
5
6	# work out which endpoints to listen on
7	$endpoints = @()	×
8	@(Get-PodeEndpoints -Type Ws) \| ForEach-Object {	×
9	# get the ip address
10	$_ip = [string]($_.Address)	×
11	$_ip = (Get-PodeIPAddressesForHostname -Hostname $_ip -Type All \| Select-Object -First 1)	×
12	$_ip = (Get-PodeIPAddress $_ip)	×
13
14	# add endpoint to list
15	$endpoints += @{	×
16	Address = $_ip	×
17	Port = $_.Port	×
18	Certificate = $_.Certificate.Raw	×
19	HostName = $_.Url	×
20	}
21	}
22
23	try
24	{
25	# register endpoints on the listener
26	$endpoints \| ForEach-Object {	×
27	$PodeContext.Server.WebSockets.Listeners += (Initialize-PodeSocketListenerEndpoint `	×
28	-Type WebSockets `
29	-Address $_.Address `
30	-Port $_.Port `
31	-Certificate $_.Certificate)
32	}
33	}
34	catch {
35	$_ \| Write-PodeErrorLog	×
36	$_.Exception \| Write-PodeErrorLog -CheckInnerException	×
37	Close-PodeSocketListener -Type WebSockets	×
38	throw $_.Exception	×
39	}
40
41	# script for listening out for incoming requests
42	$listenScript = {	×
43	param (
44	[Parameter(Mandatory=$true)]
45	[int]
46	$ThreadId
47	)
48
49	try
50	{
51	Start-PodeSocketListener -Listeners $PodeContext.Server.WebSockets.Listeners	×
52
53	[System.Threading.Thread]::CurrentThread.IsBackground = $true	×
54	[System.Threading.Thread]::CurrentThread.Priority = [System.Threading.ThreadPriority]::Lowest	×
55
56	while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)	×
57	{
58	Wait-PodeTask ([System.Threading.Tasks.Task]::Delay(60))	×
59	}
60	}
61	catch [System.OperationCanceledException] {}
62	catch {
63	$_ \| Write-PodeErrorLog	×
64	$_.Exception \| Write-PodeErrorLog -CheckInnerException	×
65	throw $_.Exception	×
66	}
67	}
68
69	# start the runspace for listening on x-number of threads
70	1..$PodeContext.Threads.Web \| ForEach-Object {	×
71	Add-PodeRunspace -Type 'Signals' -ScriptBlock $listenScript `	×
72	-Parameters @{ 'ThreadId' = $_ }	×
73	}
74
75	# script to write messages back to the client(s)
76	$signalScript = {	×
77	try {
78	[System.Threading.Thread]::CurrentThread.IsBackground = $true	×
79	[System.Threading.Thread]::CurrentThread.Priority = [System.Threading.ThreadPriority]::Lowest	×
80
81	while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)	×
82	{
83	Wait-PodeTask ([System.Threading.Tasks.Task]::Delay(100))	×
84
85	# check if we have any messages to send
86	$message = $null	×
87	if (!$PodeContext.Server.WebSockets.Queues.Messages.TryDequeue([ref]$message)) {	×
88	$message = $null	×
89	}
90
91	if ($null -eq $message) {	×
92	continue
93	}
94
95	# get the sockets for the message
96	$sockets = @()	×
97
98	# by clientId
99	if (![string]::IsNullOrWhiteSpace($message.ClientId)) {	×
100	$sockets = @($PodeContext.Server.WebSockets.Queues.Sockets[$message.ClientId])	×
101	}
102	else {
103	$sockets = @($PodeContext.Server.WebSockets.Queues.Sockets.Values)	×
104
105	# by path
106	if (![string]::IsNullOrWhiteSpace($message.Path)) {	×
107	$sockets = @(foreach ($socket in $sockets) {	×
108	if ($socket.Path -ieq $message.Path) {	×
109	$socket	×
110	break
111	}
112	})
113	}
114	}
115
116	# do nothing if no socket found
117	if (($null -eq $sockets) -or ($sockets.Length -eq 0)) {	×
118	continue
119	}
120
121	# frame the message
122	$buffer = [byte[]]@()	×
123	$buffer += [byte]([byte]0x80 -bor [byte]1)	×
124
125	$payload = $PodeContext.Server.Encoding.GetBytes($message.Value)	×
126	if ($payload.Length -lt 126) {	×
127	$buffer += [byte]([byte]0x00 -bor [byte]$payload.Length)	×
128	}
129	elseif ($payload.Length -le [uint16]::MaxValue) {	×
130	$buffer += [byte]([byte]0x00 -bor [byte]126)	×
131	}
132	else {
133	$buffer += [byte]([byte]0x00 -bor [byte]127)	×
134	}
135
136	$buffer += $payload	×
137
138	# send the message to all found sockets
139	foreach ($socket in $sockets) {	×
140	try {
141	Wait-PodeTask -Task $socket.Stream.WriteAsync($buffer, 0, $buffer.Length)	×
142	}
143	catch {
144	$PodeContext.Server.WebSockets.Queues.Sockets.Remove($socket.ClientId) \| Out-Null	×
145	}
146	}
147	}
148	}
149	catch [System.OperationCanceledException] {}
150	catch {
151	$_ \| Write-PodeErrorLog	×
152	$_.Exception \| Write-PodeErrorLog -CheckInnerException	×
153	throw $_.Exception	×
154	}
155	}
156
157	Add-PodeRunspace -Type 'Signals' -ScriptBlock $signalScript	×
158
159	# script to keep web server listening until cancelled
160	$waitScript = {	×
161	try {
162	while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested) {	×
163	Start-Sleep -Seconds 1	×
164	}
165	}
166	catch [System.OperationCanceledException] {}
167	catch {
168	$_ \| Write-PodeErrorLog	×
169	$_.Exception \| Write-PodeErrorLog -CheckInnerException	×
170	throw $_.Exception	×
171	}
172	finally {
173	Close-PodeSocketListener -Type WebSockets	×
174	}
175	}
176
177	Add-PodeRunspace -Type 'Signals' -ScriptBlock $waitScript	×
178	return @($endpoints.HostName)	×
179	}
180
181	function Invoke-PodeWebSocketHandler
182	{
183	param(
184	[Parameter(Mandatory)]
185	[hashtable]
186	$Context
187	)
188
189	try
190	{
191	# make the stream (use an ssl stream if we have a cert)
192	$stream = [System.Net.Sockets.NetworkStream]::new($Context.Socket, $true)	×
193
194	if ($null -ne $Context.Certificate) {	×
195	try {
196	$stream = [System.Net.Security.SslStream]::new($stream, $false, $PodeContext.Server.WebSockets.Ssl.Callback)	×
197	$stream.AuthenticateAsServer($Context.Certificate, $false, $PodeContext.Server.WebSockets.Ssl.Protocols, $false)	×
198	}
199	catch {
200	# immediately close http connections
201	Close-PodeSocket -Socket $Context.Socket -Shutdown	×
202	return
203	}
204	}
205
206	# read the request headers - once again, I apologise profusely.
207	try {
208	$bytes = New-Object byte[] 0	×
209	$Context.Socket.Receive($bytes) \| Out-Null	×
210	}
211	catch {
212	$err = [System.Net.Http.HttpRequestException]::new()	×
213	$err.Data.Add('PodeStatusCode', 408)	×
214	throw $err	×
215	}
216
217	$bytes = New-Object byte[] $Context.Socket.Available	×
218	(Wait-PodeTask -Task $stream.ReadAsync($bytes, 0, $Context.Socket.Available)) \| Out-Null	×
219	$req_info = Get-PodeServerRequestDetails -Bytes $bytes -Protocol $Context.Protocol	×
220
221	# if the method is not a GET, close immediately
222	if ($req_info.Method -ine 'GET') {	×
223	Close-PodeSocket -Socket $Context.Socket -Shutdown	×
224	return
225	}
226	}
227	catch [System.OperationCanceledException] {}
228	catch [System.Net.Http.HttpRequestException] {
229	$code = [int]($_.Exception.Data['PodeStatusCode'])	×
230	if ($code -le 0) {	×
231	$code = 400	×
232	}
233
234	Set-PodeResponseStatus -Code $code -Exception $_	×
235	}
236	catch {
237	$_ \| Write-PodeErrorLog	×
238	$_.Exception \| Write-PodeErrorLog -CheckInnerException	×
239	Set-PodeResponseStatus -Code 500 -Exception $_	×
240	}
241
242	try {
243	# get the path, and generate a clientId
244	$path = $req_info.Uri.AbsolutePath	×
245	$clientId = New-PodeGuid -Secure	×
246
247	# send back headers to upgrade the client to a websocket
248	$magicGuid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'	×
249	$secSocketKey = $req_info.Headers['Sec-WebSocket-Key'].Trim()	×
250
251	$resHeaders = @{	×
252	'Connection' = 'Upgrade'	×
253	'Upgrade' = 'websocket'	×
254	'Sec-WebSocket-Accept' = Invoke-PodeSHA1Hash -Value "$($secSocketKey)$($magicGuid)"	×
255	'X-Pode-ClientId' = $clientId	×
256	}
257
258	# write the response line
259	$protocol = $req_info.Protocol	×
260	if ([string]::IsNullOrWhiteSpace($protocol)) {	×
261	$protocol = 'HTTP/1.1'	×
262	}
263
264	$newLine = "`r`n"	×
265	$res_msg = "$($protocol) 101 Switching Protocols$($newLine)"	×
266
267	# write the response headers
268	foreach ($key in $resHeaders.Keys) {	×
269	$res_msg += "$($key): $($resHeaders[$key])$($newLine)"	×
270	}
271
272	$res_msg += $newLine	×
273
274	# stream response output
275	$buffer = $PodeContext.Server.Encoding.GetBytes($res_msg)	×
276	Wait-PodeTask -Task $stream.WriteAsync($buffer, 0, $buffer.Length)	×
277
278	# add the socket/stream to all sockets, and path sockets (and clientId)
279	$PodeContext.Server.WebSockets.Queues.Sockets[$clientId] = @{	×
280	Socket = $Context.Socket	×
281	Stream = $stream	×
282	Path = $path	×
283	ClientId = $clientId	×
284	}
285	}
286	catch [System.Management.Automation.MethodInvocationException] { }
287	}

Badgerati / Pode / #530

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous