#562

pending completion

Build # #562

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/dd2d2194caa0d9add7d9d057222dddfc18a5ac9f">dd2d2194c<a href="https://github.com/Badgerati/Pode/commit/dd2d2194caa0d9add7d9d057222dddfc18a5ac9f">">Merge </a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/<a class="double-link" href="https://github.com/Badgerati/Pode/commit/a3912e7c50bf9a8d15db4b6c675bfa639bba5ed8">a3912e7c5</a>">a3912e7c5</a><a href="https://github.com/Badgerati/Pode/commit/dd2d2194caa0d9add7d9d057222dddfc18a5ac9f"> into e41256424">e41256424</a>

Run Details

45 of 45 new or added lines in 7 files covered. (100.0%)

2393 of 5345 relevant lines covered (44.77%)

1.15 hits per line

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

0.0

/src/Private/PodeServer.ps1

function Start-PodeSocketServer
{
    param (
        [switch]
        $Browse
    )

    # setup the callback for sockets
    $PodeContext.Server.Sockets.Ssl.Callback = Get-PodeSocketCertifcateCallback

    # setup any inbuilt middleware
    $inbuilt_middleware = @(
        (Get-PodeAccessMiddleware),
        (Get-PodeLimitMiddleware),
        (Get-PodePublicMiddleware),
        (Get-PodeRouteValidateMiddleware),
        (Get-PodeBodyMiddleware),
        (Get-PodeCookieMiddleware)
    )

    $PodeContext.Server.Middleware = ($inbuilt_middleware + $PodeContext.Server.Middleware)

    # work out which endpoints to listen on
    $endpoints = @()
    @(Get-PodeEndpoints -Type Http) | 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.Sockets.Listeners += (Initialize-PodeSocketListenerEndpoint `
                -Type Sockets `
                -Address $_.Address `
                -Port $_.Port `
                -Certificate $_.Certificate)
        }
    }
    catch {
        $_ | Write-PodeErrorLog
        $_.Exception | Write-PodeErrorLog -CheckInnerException
        Close-PodeSocketListener -Type Sockets
        throw $_.Exception
    }

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

        try
        {
            Start-PodeSocketListener -Listeners $PodeContext.Server.Sockets.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 'Main' -ScriptBlock $listenScript `
            -Parameters @{ 'ThreadId' = $_ }
    }

    # 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 Sockets
        }
    }

    Add-PodeRunspace -Type 'Main' -ScriptBlock $waitScript

    # browse to the first endpoint, if flagged
    if ($Browse) {
        Start-Process $endpoints[0].HostName
    }

    return @($endpoints.HostName)
}

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

    try
    {
        # reset with basic event data
        $WebEvent = @{
            OnEnd = @()
            Auth = @{}
            Response = @{
                Headers = @{}
                ContentLength64 = 0
                ContentType = $null
                OutputStream = New-Object -TypeName System.IO.MemoryStream
                StatusCode = 200
                StatusDescription = 'OK'
            }
            Request = @{}
            Lockable = $PodeContext.Lockable
            Path = $null
            Method = $null
            Query = $null
            Protocol = $Context.Protocol
            Endpoint = $null
            ContentType = $null
            ErrorType = $null
            Cookies = @{}
            PendingCookies = @{}
            Parameters = $null
            Data = $null
            Files = $null
            Streamed = $true
            Timestamp = [datetime]::UtcNow
        }

        # set pode in server response header
        Set-PodeServerHeader

        # 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.Sockets.Ssl.Callback)
                $stream.AuthenticateAsServer($Context.Certificate, $true, $PodeContext.Server.Sockets.Ssl.Protocols, $false)
            }
            catch {
                # immediately close http connections
                Close-PodeSocket -Socket $Context.Socket -Shutdown
                return
            }
        }

        # read the request headers - prepare for the dodgest of hacks ever. 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

        # set the rest of the event data
        $WebEvent.Request = @{
            Body = @{
                Value = $req_info.Body
                Bytes = $req_info.RawBody
            }
            Headers = $req_info.Headers
            Url = $req_info.Uri
            UrlReferrer = $req_info.Headers['Referer']
            UserAgent = $req_info.Headers['User-Agent']
            HttpMethod = $req_info.Method
            RemoteEndPoint = $Context.Socket.RemoteEndPoint
            Protocol = $req_info.Protocol
            ProtocolVersion = ($req_info.Protocol -isplit '/')[1]
            ContentEncoding = (Get-PodeEncodingFromContentType -ContentType $req_info.Headers['Content-Type'])
        }

        $WebEvent.Path = $req_info.Uri.AbsolutePath
        $WebEvent.Method = $req_info.Method.ToLowerInvariant()
        $WebEvent.Endpoint = $req_info.Headers['Host']
        $WebEvent.ContentType = $req_info.Headers['Content-Type']

        # parse the query string and convert it to a hashtable
        $tmpQuery = [System.Web.HttpUtility]::ParseQueryString($req_info.Query.TrimStart('/', '?'))
        $WebEvent.Query = (ConvertFrom-PodeNameValueToHashTable -Collection $tmpQuery)

        # add logging endware for post-request
        Add-PodeRequestLogEndware -WebEvent $WebEvent

        # invoke middleware
        if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $PodeContext.Server.Middleware -Route $WebEvent.Path)) {
            # get the route logic
            $route = Find-PodeRoute -Method $WebEvent.Method -Route $WebEvent.Path -Protocol $WebEvent.Protocol `
                -Endpoint $WebEvent.Endpoint -CheckWildMethod

            # invoke route and custom middleware
            if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $route.Middleware)) {
                if ($null -ne $route.Logic) {
                    Invoke-PodeScriptBlock -ScriptBlock $route.Logic -Arguments (@($WebEvent) + @($route.Arguments)) -Scoped -Splat
                }
            }
        }
    }
    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 {
        # invoke endware specifc to the current web event
        $_endware = ($WebEvent.OnEnd + @($PodeContext.Server.Endware))
        Invoke-PodeEndware -WebEvent $WebEvent -Endware $_endware

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

        $newLine = "`r`n"
        $res_msg = "$($protocol) $($WebEvent.Response.StatusCode) $($WebEvent.Response.StatusDescription)$($newLine)"

        # set response headers before adding
        Set-PodeServerResponseHeaders -WebEvent $WebEvent

        # write the response headers
        if ($WebEvent.Response.Headers.Count -gt 0) {
            foreach ($key in $WebEvent.Response.Headers.Keys) {
                foreach ($value in $WebEvent.Response.Headers[$key]) {
                    $res_msg += "$($key): $($value)$($newLine)"
                }
            }
        }

        $res_msg += $newLine

        # stream response output
        $buffer = $PodeContext.Server.Encoding.GetBytes($res_msg)
        Wait-PodeTask -Task $stream.WriteAsync($buffer, 0, $buffer.Length)
        $WebEvent.Response.OutputStream.WriteTo($stream)
        $stream.Flush()
    }
    catch [System.Management.Automation.MethodInvocationException] { }
    finally {
        # close socket stream
        if ($null -ne $WebEvent.Response.OutputStream) {
            Close-PodeDisposable -Disposable $WebEvent.Response.OutputStream -Close -CheckNetwork
        }

        Close-PodeSocket -Socket $Context.Socket -Shutdown
    }
}

function Set-PodeServerResponseHeaders
{
    param(
        [Parameter(Mandatory=$true)]
        $WebEvent
    )

    # add content-type
    if (![string]::IsNullOrWhiteSpace($WebEvent.Response.ContentType)) {
        Set-PodeHeader -Name 'Content-Type' -Value $WebEvent.Response.ContentType
    }
    else {
        $WebEvent.Response.Headers.Remove('Content-Type')
    }

    # add content-length
    if (($WebEvent.Response.ContentLength64 -eq 0) -and ($WebEvent.Response.OutputStream.Length -gt 0)) {
        $WebEvent.Response.ContentLength64 = $WebEvent.Response.OutputStream.Length
    }

    if ($WebEvent.Response.ContentLength64 -gt 0) {
        Set-PodeHeader -Name 'Content-Length' -Value $WebEvent.Response.ContentLength64
    }
    else {
        $WebEvent.Response.Headers.Remove('Content-Length')
    }

    # add the date of the response
    Set-PodeHeader -Name 'Date' -Value ([DateTime]::UtcNow.ToString("r", [CultureInfo]::InvariantCulture))

    # state to close the connection (no support for keep-alive yet)
    Set-PodeHeader -Name 'Connection' -Value 'close'
}

1	function Start-PodeSocketServer
2	{
3	param (
4	[switch]
5	$Browse
6	)
7
8	# setup the callback for sockets
9	$PodeContext.Server.Sockets.Ssl.Callback = Get-PodeSocketCertifcateCallback	×
10
11	# setup any inbuilt middleware
12	$inbuilt_middleware = @(	×
13	(Get-PodeAccessMiddleware),	×
14	(Get-PodeLimitMiddleware),	×
15	(Get-PodePublicMiddleware),	×
16	(Get-PodeRouteValidateMiddleware),	×
17	(Get-PodeBodyMiddleware),	×
18	(Get-PodeCookieMiddleware)	×
19	)
20
21	$PodeContext.Server.Middleware = ($inbuilt_middleware + $PodeContext.Server.Middleware)	×
22
23	# work out which endpoints to listen on
24	$endpoints = @()	×
25	@(Get-PodeEndpoints -Type Http) \| ForEach-Object {	×
26	# get the ip address
27	$_ip = [string]($_.Address)	×
28	$_ip = (Get-PodeIPAddressesForHostname -Hostname $_ip -Type All \| Select-Object -First 1)	×
29	$_ip = (Get-PodeIPAddress $_ip)	×
30
31	# add endpoint to list
32	$endpoints += @{	×
33	Address = $_ip	×
34	Port = $_.Port	×
35	Certificate = $_.Certificate.Raw	×
36	HostName = $_.Url	×
37	}
38	}
39
40	try
41	{
42	# register endpoints on the listener
43	$endpoints \| ForEach-Object {	×
44	$PodeContext.Server.Sockets.Listeners += (Initialize-PodeSocketListenerEndpoint `	×
45	-Type Sockets `
46	-Address $_.Address `
47	-Port $_.Port `
48	-Certificate $_.Certificate)
49	}
50	}
51	catch {
52	$_ \| Write-PodeErrorLog	×
53	$_.Exception \| Write-PodeErrorLog -CheckInnerException	×
54	Close-PodeSocketListener -Type Sockets	×
55	throw $_.Exception	×
56	}
57
58	# script for listening out for incoming requests
59	$listenScript = {	×
60	param (
61	[Parameter(Mandatory=$true)]
62	[int]
63	$ThreadId
64	)
65
66	try
67	{
68	Start-PodeSocketListener -Listeners $PodeContext.Server.Sockets.Listeners	×
69
70	[System.Threading.Thread]::CurrentThread.IsBackground = $true	×
71	[System.Threading.Thread]::CurrentThread.Priority = [System.Threading.ThreadPriority]::Lowest	×
72
73	while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)	×
74	{
75	Wait-PodeTask ([System.Threading.Tasks.Task]::Delay(60))	×
76	}
77	}
78	catch [System.OperationCanceledException] {}
79	catch {
80	$_ \| Write-PodeErrorLog	×
81	$_.Exception \| Write-PodeErrorLog -CheckInnerException	×
82	throw $_.Exception	×
83	}
84	}
85
86	# start the runspace for listening on x-number of threads
87	1..$PodeContext.Threads.Web \| ForEach-Object {	×
88	Add-PodeRunspace -Type 'Main' -ScriptBlock $listenScript `	×
89	-Parameters @{ 'ThreadId' = $_ }	×
90	}
91
92	# script to keep web server listening until cancelled
93	$waitScript = {	×
94	try {
95	while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested) {	×
96	Start-Sleep -Seconds 1	×
97	}
98	}
99	catch [System.OperationCanceledException] {}
100	catch {
101	$_ \| Write-PodeErrorLog	×
102	$_.Exception \| Write-PodeErrorLog -CheckInnerException	×
103	throw $_.Exception	×
104	}
105	finally {
106	Close-PodeSocketListener -Type Sockets	×
107	}
108	}
109
110	Add-PodeRunspace -Type 'Main' -ScriptBlock $waitScript	×
111
112	# browse to the first endpoint, if flagged
113	if ($Browse) {	×
114	Start-Process $endpoints[0].HostName	×
115	}
116
117	return @($endpoints.HostName)	×
118	}
119
120	function Invoke-PodeSocketHandler
121	{
122	param(
123	[Parameter(Mandatory)]
124	[hashtable]
125	$Context
126	)
127
128	try
129	{
130	# reset with basic event data
131	$WebEvent = @{	×
132	OnEnd = @()	×
133	Auth = @{}	×
134	Response = @{	×
135	Headers = @{}	×
136	ContentLength64 = 0	×
137	ContentType = $null	×
138	OutputStream = New-Object -TypeName System.IO.MemoryStream	×
139	StatusCode = 200	×
140	StatusDescription = 'OK'	×
141	}
142	Request = @{}	×
143	Lockable = $PodeContext.Lockable	×
144	Path = $null	×
145	Method = $null	×
146	Query = $null	×
147	Protocol = $Context.Protocol	×
148	Endpoint = $null	×
149	ContentType = $null	×
150	ErrorType = $null	×
151	Cookies = @{}	×
152	PendingCookies = @{}	×
153	Parameters = $null	×
154	Data = $null	×
155	Files = $null	×
156	Streamed = $true	×
157	Timestamp = [datetime]::UtcNow	×
158	}
159
160	# set pode in server response header
161	Set-PodeServerHeader	×
162
163	# make the stream (use an ssl stream if we have a cert)
164	$stream = [System.Net.Sockets.NetworkStream]::new($Context.Socket, $true)	×
165
166	if ($null -ne $Context.Certificate) {	×
167	try {
168	$stream = [System.Net.Security.SslStream]::new($stream, $false, $PodeContext.Server.Sockets.Ssl.Callback)	×
169	$stream.AuthenticateAsServer($Context.Certificate, $true, $PodeContext.Server.Sockets.Ssl.Protocols, $false)	×
170	}
171	catch {
172	# immediately close http connections
173	Close-PodeSocket -Socket $Context.Socket -Shutdown	×
174	return
175	}
176	}
177
178	# read the request headers - prepare for the dodgest of hacks ever. I apologise profusely.
179	try {
180	$bytes = New-Object byte[] 0	×
181	$Context.Socket.Receive($bytes) \| Out-Null	×
182	}
183	catch {
184	$err = [System.Net.Http.HttpRequestException]::new()	×
185	$err.Data.Add('PodeStatusCode', 408)	×
186	throw $err	×
187	}
188
189	$bytes = New-Object byte[] $Context.Socket.Available	×
190	(Wait-PodeTask -Task $stream.ReadAsync($bytes, 0, $Context.Socket.Available)) \| Out-Null	×
191	$req_info = Get-PodeServerRequestDetails -Bytes $bytes -Protocol $Context.Protocol	×
192
193	# set the rest of the event data
194	$WebEvent.Request = @{	×
195	Body = @{	×
196	Value = $req_info.Body	×
197	Bytes = $req_info.RawBody	×
198	}
199	Headers = $req_info.Headers	×
200	Url = $req_info.Uri	×
201	UrlReferrer = $req_info.Headers['Referer']	×
202	UserAgent = $req_info.Headers['User-Agent']	×
203	HttpMethod = $req_info.Method	×
204	RemoteEndPoint = $Context.Socket.RemoteEndPoint	×
205	Protocol = $req_info.Protocol	×
206	ProtocolVersion = ($req_info.Protocol -isplit '/')[1]	×
207	ContentEncoding = (Get-PodeEncodingFromContentType -ContentType $req_info.Headers['Content-Type'])	×
208	}
209
210	$WebEvent.Path = $req_info.Uri.AbsolutePath	×
211	$WebEvent.Method = $req_info.Method.ToLowerInvariant()	×
212	$WebEvent.Endpoint = $req_info.Headers['Host']	×
213	$WebEvent.ContentType = $req_info.Headers['Content-Type']	×
214
215	# parse the query string and convert it to a hashtable
216	$tmpQuery = [System.Web.HttpUtility]::ParseQueryString($req_info.Query.TrimStart('/', '?'))	×
217	$WebEvent.Query = (ConvertFrom-PodeNameValueToHashTable -Collection $tmpQuery)	×
218
219	# add logging endware for post-request
220	Add-PodeRequestLogEndware -WebEvent $WebEvent	×
221
222	# invoke middleware
223	if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $PodeContext.Server.Middleware -Route $WebEvent.Path)) {	×
224	# get the route logic
225	$route = Find-PodeRoute -Method $WebEvent.Method -Route $WebEvent.Path -Protocol $WebEvent.Protocol `	×
226	-Endpoint $WebEvent.Endpoint -CheckWildMethod
227
228	# invoke route and custom middleware
229	if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $route.Middleware)) {	×
230	if ($null -ne $route.Logic) {	×
231	Invoke-PodeScriptBlock -ScriptBlock $route.Logic -Arguments (@($WebEvent) + @($route.Arguments)) -Scoped -Splat	×
232	}
233	}
234	}
235	}
236	catch [System.OperationCanceledException] {}
237	catch [System.Net.Http.HttpRequestException] {
238	$code = [int]($_.Exception.Data['PodeStatusCode'])	×
239	if ($code -le 0) {	×
240	$code = 400	×
241	}
242
243	Set-PodeResponseStatus -Code $code -Exception $_	×
244	}
245	catch {
246	$_ \| Write-PodeErrorLog	×
247	$_.Exception \| Write-PodeErrorLog -CheckInnerException	×
248	Set-PodeResponseStatus -Code 500 -Exception $_	×
249	}
250
251	try {
252	# invoke endware specifc to the current web event
253	$_endware = ($WebEvent.OnEnd + @($PodeContext.Server.Endware))	×
254	Invoke-PodeEndware -WebEvent $WebEvent -Endware $_endware	×
255
256	# write the response line
257	$protocol = $req_info.Protocol	×
258	if ([string]::IsNullOrWhiteSpace($protocol)) {	×
259	$protocol = 'HTTP/1.1'	×
260	}
261
262	$newLine = "`r`n"	×
263	$res_msg = "$($protocol) $($WebEvent.Response.StatusCode) $($WebEvent.Response.StatusDescription)$($newLine)"	×
264
265	# set response headers before adding
266	Set-PodeServerResponseHeaders -WebEvent $WebEvent	×
267
268	# write the response headers
269	if ($WebEvent.Response.Headers.Count -gt 0) {	×
270	foreach ($key in $WebEvent.Response.Headers.Keys) {	×
271	foreach ($value in $WebEvent.Response.Headers[$key]) {	×
272	$res_msg += "$($key): $($value)$($newLine)"	×
273	}
274	}
275	}
276
277	$res_msg += $newLine	×
278
279	# stream response output
280	$buffer = $PodeContext.Server.Encoding.GetBytes($res_msg)	×
281	Wait-PodeTask -Task $stream.WriteAsync($buffer, 0, $buffer.Length)	×
282	$WebEvent.Response.OutputStream.WriteTo($stream)	×
283	$stream.Flush()	×
284	}
285	catch [System.Management.Automation.MethodInvocationException] { }
286	finally {
287	# close socket stream
288	if ($null -ne $WebEvent.Response.OutputStream) {	×
289	Close-PodeDisposable -Disposable $WebEvent.Response.OutputStream -Close -CheckNetwork	×
290	}
291
292	Close-PodeSocket -Socket $Context.Socket -Shutdown	×
293	}
294	}
295
296	function Set-PodeServerResponseHeaders
297	{
298	param(
299	[Parameter(Mandatory=$true)]
300	$WebEvent
301	)
302
303	# add content-type
304	if (![string]::IsNullOrWhiteSpace($WebEvent.Response.ContentType)) {	×
305	Set-PodeHeader -Name 'Content-Type' -Value $WebEvent.Response.ContentType	×
306	}
307	else {
308	$WebEvent.Response.Headers.Remove('Content-Type')	×
309	}
310
311	# add content-length
312	if (($WebEvent.Response.ContentLength64 -eq 0) -and ($WebEvent.Response.OutputStream.Length -gt 0)) {	×
313	$WebEvent.Response.ContentLength64 = $WebEvent.Response.OutputStream.Length	×
314	}
315
316	if ($WebEvent.Response.ContentLength64 -gt 0) {	×
317	Set-PodeHeader -Name 'Content-Length' -Value $WebEvent.Response.ContentLength64	×
318	}
319	else {
320	$WebEvent.Response.Headers.Remove('Content-Length')	×
321	}
322
323	# add the date of the response
324	Set-PodeHeader -Name 'Date' -Value ([DateTime]::UtcNow.ToString("r", [CultureInfo]::InvariantCulture))	×
325
326	# state to close the connection (no support for keep-alive yet)
327	Set-PodeHeader -Name 'Connection' -Value 'close'	×
328	}

Badgerati / Pode / #562

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