Badgerati / Pode / #72

pending completion

Build # #72

Build Type

push

appveyor

Committed by

web-flow

Commit Message

<a href="https://github.com/Badgerati/Pode/commit/<a class=hub.com/Badgerati/Pode/commit/6f423955b9b78bc5ba7629d54b6a2061c1f2a42a">6f423955b<a href="https://github.com/Badgerati/Pode/commit/6f423955b9b78bc5ba7629d54b6a2061c1f2a42a">">Merge </a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/<a class="double-link" href="https://github.com/Badgerati/Pode/commit/28ea99c2a8c83ebf99eaa94a7210c22b945defbc">28ea99c2a</a>">28ea99c2a</a><a href="https://github.com/Badgerati/Pode/commit/6f423955b9b78bc5ba7629d54b6a2061c1f2a42a"> into a772f72d7">a772f72d7</a>

Run Details

43 of 43 new or added lines in 6 files covered. (100.0%)

1770 of 3404 relevant lines covered (52.0%)

0.66 hits per line

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

0.0

/src/Tools/WebServer.ps1

function Engine
{
    param (
        [Parameter()]
        [ValidateNotNullOrEmpty()]
        [Alias('t')]
        [string]
        $Engine,

        [Parameter()]
        [Alias('s')]
        [scriptblock]
        $ScriptBlock = $null,

        [Parameter()]
        [Alias('ext')]
        [string]
        $Extension
    )

    if ([string]::IsNullOrWhiteSpace($Extension)) {
        $Extension = $Engine.ToLowerInvariant()
    }

    $PodeContext.Server.ViewEngine.Engine = $Engine.ToLowerInvariant()
    $PodeContext.Server.ViewEngine.Extension = $Extension
    $PodeContext.Server.ViewEngine.Script = $ScriptBlock
}

function Start-PodeWebServer
{
    # 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 = @()
    $PodeContext.Server.Endpoints | ForEach-Object {
        # get the protocol
        $_protocol = (iftet $_.Ssl 'https' 'http')

        # get the ip address
        $_ip = "$($_.Address)"
        if ($_ip -ieq '0.0.0.0') {
            $_ip = '*'
        }

        # get the port
        $_port = [int]($_.Port)
        if ($_port -eq 0) {
            $_port = (iftet $_.Ssl 8443 8080)
        }

        # if this endpoint is https, generate a self-signed cert or bind an existing one
        if ($_.Ssl) {
            $addr = (iftet $_.IsIPAddress $_.Address $_.HostName)
            Set-PodeCertificate -Address $addr -Port $_port -Certificate $_.Certificate.Name -Thumbprint $_.Certificate.Thumbprint
        }

        # add endpoint to list
        $endpoints += @{
            'Prefix' = "$($_protocol)://$($_ip):$($_port)/";
            'HostName' = "$($_protocol)://$($_.HostName):$($_port)/";
        }
    }

    # 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 {
        $Error[0] | Out-Default

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

            dispose $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 = (await $Listener.GetContextAsync())

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

                    # reset event data
                    $WebEvent = @{}
                    $WebEvent.OnEnd = @()
                    $WebEvent.Auth = @{}
                    $WebEvent.Response = $response
                    $WebEvent.Request = $request
                    $WebEvent.Lockable = $PodeContext.Lockable
                    $WebEvent.Path = ($request.RawUrl -isplit "\?")[0]
                    $WebEvent.Method = $request.HttpMethod.ToLowerInvariant()
                    $WebEvent.Protocol = $request.Url.Scheme
                    $WebEvent.Endpoint = $request.Url.Authority
                    $WebEvent.ContentType = $request.ContentType

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

                    # invoke middleware
                    if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $PodeContext.Server.Middleware -Route $WebEvent.Path)) {
                        # get the route logic
                        $route = Get-PodeRoute -HttpMethod $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)) {
                            Invoke-ScriptBlock -ScriptBlock $route.Logic -Arguments $WebEvent -Scoped
                        }
                    }
                }
                catch {
                    status 500 -e $_
                    $Error[0] | Out-Default
                }

                # 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) {
                    dispose $response.OutputStream -Close -CheckNetwork
                }
            }
        }
        catch [System.OperationCanceledException] {}
        catch {
            $Error[0] | Out-Default
            throw $_.Exception
        }
    }

    # start the runspace for listening on x-number of threads
    1..$PodeContext.Threads | 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 {
            $Error[0] | Out-Default
            throw $_.Exception
        }
        finally {
            if ($null -ne $Listener) {
                if ($Listener.IsListening) {
                    $Listener.Stop()
                }

                dispose $Listener -Close
            }
        }
    }

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

    # state where we're running
    Write-Host "Listening on the following $($endpoints.Length) endpoint(s) [$($PodeContext.Threads) thread(s)]:" -ForegroundColor Yellow

    $endpoints | ForEach-Object {
        Write-Host "`t- $($_.HostName)" -ForegroundColor Yellow
    }
}

1	function Engine
2	{
3	param (
4	[Parameter()]
5	[ValidateNotNullOrEmpty()]
6	[Alias('t')]
7	[string]
8	$Engine,
9
10	[Parameter()]
11	[Alias('s')]
12	[scriptblock]
13	$ScriptBlock = $null,
14
15	[Parameter()]
16	[Alias('ext')]
17	[string]
18	$Extension
19	)
20
21	if ([string]::IsNullOrWhiteSpace($Extension)) {	×
22	$Extension = $Engine.ToLowerInvariant()	×
23	}
24
25	$PodeContext.Server.ViewEngine.Engine = $Engine.ToLowerInvariant()	×
26	$PodeContext.Server.ViewEngine.Extension = $Extension	×
27	$PodeContext.Server.ViewEngine.Script = $ScriptBlock	×
28	}
29
30	function Start-PodeWebServer
31	{
32	# setup any inbuilt middleware
33	$inbuilt_middleware = @(	×
34	(Get-PodeAccessMiddleware),	×
35	(Get-PodeLimitMiddleware),	×
36	(Get-PodePublicMiddleware),	×
37	(Get-PodeRouteValidateMiddleware),	×
38	(Get-PodeBodyMiddleware),	×
39	(Get-PodeQueryMiddleware)	×
40	)
41
42	$PodeContext.Server.Middleware = ($inbuilt_middleware + $PodeContext.Server.Middleware)	×
43
44	# work out which endpoints to listen on
45	$endpoints = @()	×
46	$PodeContext.Server.Endpoints \| ForEach-Object {	×
47	# get the protocol
48	$_protocol = (iftet $_.Ssl 'https' 'http')	×
49
50	# get the ip address
51	$_ip = "$($_.Address)"	×
52	if ($_ip -ieq '0.0.0.0') {	×
53	$_ip = '*'	×
54	}
55
56	# get the port
57	$_port = [int]($_.Port)	×
58	if ($_port -eq 0) {	×
59	$_port = (iftet $_.Ssl 8443 8080)	×
60	}
61
62	# if this endpoint is https, generate a self-signed cert or bind an existing one
63	if ($_.Ssl) {	×
64	$addr = (iftet $_.IsIPAddress $_.Address $_.HostName)	×
65	Set-PodeCertificate -Address $addr -Port $_port -Certificate $_.Certificate.Name -Thumbprint $_.Certificate.Thumbprint	×
66	}
67
68	# add endpoint to list
69	$endpoints += @{	×
70	'Prefix' = "$($_protocol)://$($_ip):$($_port)/";	×
71	'HostName' = "$($_protocol)://$($_.HostName):$($_port)/";	×
72	}
73	}
74
75	# create the listener on http and/or https
76	$listener = New-Object System.Net.HttpListener	×
77
78	try
79	{
80	# start listening on defined endpoints
81	$endpoints \| ForEach-Object {	×
82	$listener.Prefixes.Add($_.Prefix)	×
83	}
84
85	$listener.Start()	×
86	}
87	catch {
88	$Error[0] \| Out-Default	×
89
90	if ($null -ne $Listener) {	×
91	if ($Listener.IsListening) {	×
92	$Listener.Stop()	×
93	}
94
95	dispose $Listener -Close	×
96	}
97
98	throw $_.Exception	×
99	}
100
101	# script for listening out for incoming requests
102	$listenScript = {	×
103	param (
104	[Parameter(Mandatory=$true)]
105	[ValidateNotNull()]
106	$Listener,
107
108	[Parameter(Mandatory=$true)]
109	[int]
110	$ThreadId
111	)
112
113	try
114	{
115	while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested)	×
116	{
117	# get request and response
118	$context = (await $Listener.GetContextAsync())	×
119
120	try
121	{
122	$request = $context.Request	×
123	$response = $context.Response	×
124
125	# reset event data
126	$WebEvent = @{}	×
127	$WebEvent.OnEnd = @()	×
128	$WebEvent.Auth = @{}	×
129	$WebEvent.Response = $response	×
130	$WebEvent.Request = $request	×
131	$WebEvent.Lockable = $PodeContext.Lockable	×
132	$WebEvent.Path = ($request.RawUrl -isplit "\?")[0]	×
133	$WebEvent.Method = $request.HttpMethod.ToLowerInvariant()	×
134	$WebEvent.Protocol = $request.Url.Scheme	×
135	$WebEvent.Endpoint = $request.Url.Authority	×
136	$WebEvent.ContentType = $request.ContentType	×
137
138	# add logging endware for post-request
139	Add-PodeLogEndware -WebEvent $WebEvent	×
140
141	# invoke middleware
142	if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $PodeContext.Server.Middleware -Route $WebEvent.Path)) {	×
143	# get the route logic
144	$route = Get-PodeRoute -HttpMethod $WebEvent.Method -Route $WebEvent.Path -Protocol $WebEvent.Protocol `	×
145	-Endpoint $WebEvent.Endpoint -CheckWildMethod
146
147	# invoke route and custom middleware
148	if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $route.Middleware)) {	×
149	Invoke-ScriptBlock -ScriptBlock $route.Logic -Arguments $WebEvent -Scoped	×
150	}
151	}
152	}
153	catch {
154	status 500 -e $_	×
155	$Error[0] \| Out-Default	×
156	}
157
158	# invoke endware specifc to the current web event
159	$_endware = ($WebEvent.OnEnd + @($PodeContext.Server.Endware))	×
160	Invoke-PodeEndware -WebEvent $WebEvent -Endware $_endware	×
161
162	# close response stream (check if exists, as closing the writer closes this stream on unix)
163	if ($response.OutputStream) {	×
164	dispose $response.OutputStream -Close -CheckNetwork	×
165	}
166	}
167	}
168	catch [System.OperationCanceledException] {}
169	catch {
170	$Error[0] \| Out-Default	×
171	throw $_.Exception	×
172	}
173	}
174
175	# start the runspace for listening on x-number of threads
176	1..$PodeContext.Threads \| ForEach-Object {	×
177	Add-PodeRunspace -Type 'Main' -ScriptBlock $listenScript `	×
178	-Parameters @{ 'Listener' = $listener; 'ThreadId' = $_ }	×
179	}
180
181	# script to keep web server listening until cancelled
182	$waitScript = {	×
183	param (
184	[Parameter(Mandatory=$true)]
185	[ValidateNotNull()]
186	$Listener
187	)
188
189	try
190	{
191	while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested)	×
192	{
193	Start-Sleep -Seconds 1	×
194	}
195	}
196	catch [System.OperationCanceledException] {}
197	catch {
198	$Error[0] \| Out-Default	×
199	throw $_.Exception	×
200	}
201	finally {
202	if ($null -ne $Listener) {	×
203	if ($Listener.IsListening) {	×
204	$Listener.Stop()	×
205	}
206
207	dispose $Listener -Close	×
208	}
209	}
210	}
211
212	Add-PodeRunspace -Type 'Main' -ScriptBlock $waitScript -Parameters @{ 'Listener' = $listener }	×
213
214	# state where we're running
215	Write-Host "Listening on the following $($endpoints.Length) endpoint(s) [$($PodeContext.Threads) thread(s)]:" -ForegroundColor Yellow	×
216
217	$endpoints \| ForEach-Object {	×
218	Write-Host "`t- $($_.HostName)" -ForegroundColor Yellow	×
219	}
220	}

Badgerati / Pode / #72

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