#565

pending completion

Build # #565

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/9eb8711f5c77b630c3a5209b517ba294981ba3ad">9eb8711f5<a href="https://github.com/Badgerati/Pode/commit/9eb8711f5c77b630c3a5209b517ba294981ba3ad">">Merge </a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/<a class="double-link" href="https://github.com/Badgerati/Pode/commit/f8d2776116cb18609f2632de8d2aeabd70c36358">f8d277611</a>">f8d277611</a><a href="https://github.com/Badgerati/Pode/commit/9eb8711f5c77b630c3a5209b517ba294981ba3ad"> into 910fec65d">910fec65d</a>

Run Details

86 of 86 new or added lines in 10 files covered. (100.0%)

2400 of 5362 relevant lines covered (44.76%)

1.15 hits per line

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

0.0

/src/Private/WebServer.ps1

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

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

    $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 = "$($_.Address)"
        if ($_ip -ieq '0.0.0.0') {
            $_ip = '*'
        }

        # if this endpoint is https, generate a self-signed cert or bind an existing one
        if ($_.Ssl) {
            $addr = (Resolve-PodeValue -Check $_.IsIPAddress -TrueValue $_.Address -FalseValue $_.HostName)
            $selfSigned = $_.Certificate.SelfSigned
            Set-PodeCertificate -Address $addr -Port $_.Port -Certificate $_.Certificate.Name -Thumbprint $_.Certificate.Thumbprint -SelfSigned:$selfSigned
        }

        # add endpoint to list
        $endpoints += @{
            Prefix = "$($_.Protocol)://$($_ip):$($_.Port)/"
            HostName = $_.Url
        }
    }

    # create the listener on http and/or https
    $listener = New-Object System.Net.HttpListener

    try
    {
        # start listening on defined endpoints
        $endpoints | ForEach-Object {
            $listener.Prefixes.Add($_.Prefix)
        }

        $listener.Start()
    }
    catch {
        $_ | Write-PodeErrorLog

        if ($null -ne $Listener) {
            if ($Listener.IsListening) {
                $Listener.Stop()
            }

            Close-PodeDisposable -Disposable $Listener -Close
        }

        throw $_.Exception
    }

    # script for listening out for incoming requests
    $listenScript = {
        param (
            [Parameter(Mandatory=$true)]
            [ValidateNotNull()]
            $Listener,

            [Parameter(Mandatory=$true)]
            [int]
            $ThreadId
        )

        try
        {
            while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested)
            {
                # get request and response
                $context = (Wait-PodeTask -Task $Listener.GetContextAsync())

                try
                {
                    $request = $context.Request
                    $response = $context.Response

                    # reset event data
                    $WebEvent = @{
                        OnEnd = @()
                        Auth = @{}
                        Response = $response
                        Request = $request
                        Lockable = $PodeContext.Lockable
                        Path = ($request.RawUrl -isplit "\?")[0]
                        Method = $request.HttpMethod.ToLowerInvariant()
                        Protocol = $request.Url.Scheme
                        Endpoint = $request.Url.Authority
                        ContentType = $request.ContentType
                        ErrorType = $null
                        Cookies = $request.Cookies
                        PendingCookies = @{}
                        Streamed = $true
                        Route = $null
                        Timestamp = [datetime]::UtcNow
                    }

                    # set pode in server response header
                    Set-PodeServerHeader -AllowEmptyType

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

                    # invoke middleware
                    if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $PodeContext.Server.Middleware -Route $WebEvent.Path)) {
                        # invoke route and custom middleware
                        if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $WebEvent.Route.Middleware)) {
                            if ($null -ne $WebEvent.Route.Logic) {
                                Invoke-PodeScriptBlock -ScriptBlock $WebEvent.Route.Logic -Arguments (@($WebEvent) + @($WebEvent.Route.Arguments)) -Scoped -Splat
                            }
                        }
                    }
                }
                catch {
                    Set-PodeResponseStatus -Code 500 -Exception $_
                    $_ | Write-PodeErrorLog
                }
                finally {
                    Update-PodeServerRequestMetrics -WebEvent $WebEvent
                }

                # invoke endware specifc to the current web event
                $_endware = ($WebEvent.OnEnd + @($PodeContext.Server.Endware))
                Invoke-PodeEndware -WebEvent $WebEvent -Endware $_endware

                # close response stream (check if exists, as closing the writer closes this stream on unix)
                if ($response.OutputStream) {
                    Close-PodeDisposable -Disposable $response.OutputStream -Close -CheckNetwork
                }
            }
        }
        catch [System.OperationCanceledException] {}
        catch {
            $_ | Write-PodeErrorLog
            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 @{ 'Listener' = $listener; 'ThreadId' = $_ }
    }

    # script to keep web server listening until cancelled
    $waitScript = {
        param (
            [Parameter(Mandatory=$true)]
            [ValidateNotNull()]
            $Listener
        )

        try
        {
            while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested)
            {
                Start-Sleep -Seconds 1
            }
        }
        catch [System.OperationCanceledException] {}
        catch {
            $_ | Write-PodeErrorLog
            throw $_.Exception
        }
        finally {
            if ($null -ne $Listener) {
                if ($Listener.IsListening) {
                    $Listener.Stop()
                }

                Close-PodeDisposable -Disposable $Listener -Close
            }
        }
    }

    Add-PodeRunspace -Type 'Main' -ScriptBlock $waitScript -Parameters @{ 'Listener' = $listener }

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

    return @($endpoints.HostName)
}

1	function Start-PodeWebServer
2	{
3	param (
4	[switch]
5	$Browse
6	)
7
8	# setup any inbuilt middleware
9	$inbuilt_middleware = @(	×
10	(Get-PodeAccessMiddleware),	×
11	(Get-PodeLimitMiddleware),	×
12	(Get-PodePublicMiddleware),	×
13	(Get-PodeRouteValidateMiddleware),	×
14	(Get-PodeBodyMiddleware),	×
15	(Get-PodeQueryMiddleware)	×
16	)
17
18	$PodeContext.Server.Middleware = ($inbuilt_middleware + $PodeContext.Server.Middleware)	×
19
20	# work out which endpoints to listen on
21	$endpoints = @()	×
22	@(Get-PodeEndpoints -Type Http) \| ForEach-Object {	×
23	# get the ip address
24	$_ip = "$($_.Address)"	×
25	if ($_ip -ieq '0.0.0.0') {	×
26	$_ip = '*'	×
27	}
28
29	# if this endpoint is https, generate a self-signed cert or bind an existing one
30	if ($_.Ssl) {	×
31	$addr = (Resolve-PodeValue -Check $_.IsIPAddress -TrueValue $_.Address -FalseValue $_.HostName)	×
32	$selfSigned = $_.Certificate.SelfSigned	×
33	Set-PodeCertificate -Address $addr -Port $_.Port -Certificate $_.Certificate.Name -Thumbprint $_.Certificate.Thumbprint -SelfSigned:$selfSigned	×
34	}
35
36	# add endpoint to list
37	$endpoints += @{	×
38	Prefix = "$($_.Protocol)://$($_ip):$($_.Port)/"	×
39	HostName = $_.Url	×
40	}
41	}
42
43	# create the listener on http and/or https
44	$listener = New-Object System.Net.HttpListener	×
45
46	try
47	{
48	# start listening on defined endpoints
49	$endpoints \| ForEach-Object {	×
50	$listener.Prefixes.Add($_.Prefix)	×
51	}
52
53	$listener.Start()	×
54	}
55	catch {
56	$_ \| Write-PodeErrorLog	×
57
58	if ($null -ne $Listener) {	×
59	if ($Listener.IsListening) {	×
60	$Listener.Stop()	×
61	}
62
63	Close-PodeDisposable -Disposable $Listener -Close	×
64	}
65
66	throw $_.Exception	×
67	}
68
69	# script for listening out for incoming requests
70	$listenScript = {	×
71	param (
72	[Parameter(Mandatory=$true)]
73	[ValidateNotNull()]
74	$Listener,
75
76	[Parameter(Mandatory=$true)]
77	[int]
78	$ThreadId
79	)
80
81	try
82	{
83	while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested)	×
84	{
85	# get request and response
86	$context = (Wait-PodeTask -Task $Listener.GetContextAsync())	×
87
88	try
89	{
90	$request = $context.Request	×
91	$response = $context.Response	×
92
93	# reset event data
94	$WebEvent = @{	×
95	OnEnd = @()	×
96	Auth = @{}	×
97	Response = $response	×
98	Request = $request	×
99	Lockable = $PodeContext.Lockable	×
100	Path = ($request.RawUrl -isplit "\?")[0]	×
101	Method = $request.HttpMethod.ToLowerInvariant()	×
102	Protocol = $request.Url.Scheme	×
103	Endpoint = $request.Url.Authority	×
104	ContentType = $request.ContentType	×
105	ErrorType = $null	×
106	Cookies = $request.Cookies	×
107	PendingCookies = @{}	×
108	Streamed = $true	×
109	Route = $null	×
110	Timestamp = [datetime]::UtcNow	×
111	}
112
113	# set pode in server response header
114	Set-PodeServerHeader -AllowEmptyType	×
115
116	# add logging endware for post-request
117	Add-PodeRequestLogEndware -WebEvent $WebEvent	×
118
119	# invoke middleware
120	if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $PodeContext.Server.Middleware -Route $WebEvent.Path)) {	×
121	# invoke route and custom middleware
122	if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $WebEvent.Route.Middleware)) {	×
123	if ($null -ne $WebEvent.Route.Logic) {	×
124	Invoke-PodeScriptBlock -ScriptBlock $WebEvent.Route.Logic -Arguments (@($WebEvent) + @($WebEvent.Route.Arguments)) -Scoped -Splat	×
125	}
126	}
127	}
128	}
129	catch {
130	Set-PodeResponseStatus -Code 500 -Exception $_	×
131	$_ \| Write-PodeErrorLog	×
132	}
133	finally {
134	Update-PodeServerRequestMetrics -WebEvent $WebEvent	×
135	}
136
137	# invoke endware specifc to the current web event
138	$_endware = ($WebEvent.OnEnd + @($PodeContext.Server.Endware))	×
139	Invoke-PodeEndware -WebEvent $WebEvent -Endware $_endware	×
140
141	# close response stream (check if exists, as closing the writer closes this stream on unix)
142	if ($response.OutputStream) {	×
143	Close-PodeDisposable -Disposable $response.OutputStream -Close -CheckNetwork	×
144	}
145	}
146	}
147	catch [System.OperationCanceledException] {}
148	catch {
149	$_ \| Write-PodeErrorLog	×
150	throw $_.Exception	×
151	}
152	}
153
154	# start the runspace for listening on x-number of threads
155	1..$PodeContext.Threads.Web \| ForEach-Object {	×
156	Add-PodeRunspace -Type 'Main' -ScriptBlock $listenScript `	×
157	-Parameters @{ 'Listener' = $listener; 'ThreadId' = $_ }	×
158	}
159
160	# script to keep web server listening until cancelled
161	$waitScript = {	×
162	param (
163	[Parameter(Mandatory=$true)]
164	[ValidateNotNull()]
165	$Listener
166	)
167
168	try
169	{
170	while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested)	×
171	{
172	Start-Sleep -Seconds 1	×
173	}
174	}
175	catch [System.OperationCanceledException] {}
176	catch {
177	$_ \| Write-PodeErrorLog	×
178	throw $_.Exception	×
179	}
180	finally {
181	if ($null -ne $Listener) {	×
182	if ($Listener.IsListening) {	×
183	$Listener.Stop()	×
184	}
185
186	Close-PodeDisposable -Disposable $Listener -Close	×
187	}
188	}
189	}
190
191	Add-PodeRunspace -Type 'Main' -ScriptBlock $waitScript -Parameters @{ 'Listener' = $listener }	×
192
193	# browse to the first endpoint, if flagged
194	if ($Browse) {	×
195	Start-Process $endpoints[0].HostName	×
196	}
197
198	return @($endpoints.HostName)	×
199	}

Badgerati / Pode / #565

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