#489

pending completion

Build # #489

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/b4541b23c32cddae9ff7de8df58b7bb12f6aa259">b4541b23c<a href="https://github.com/Badgerati/Pode/commit/b4541b23c32cddae9ff7de8df58b7bb12f6aa259">">Merge </a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/<a class="double-link" href="https://github.com/Badgerati/Pode/commit/4d3eb2fe3fd48f01aefd1e43e23eabc15778adfd">4d3eb2fe3</a>">4d3eb2fe3</a><a href="https://github.com/Badgerati/Pode/commit/b4541b23c32cddae9ff7de8df58b7bb12f6aa259"> into 2d29a1a3e">2d29a1a3e</a>

Run Details

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

2277 of 4614 relevant lines covered (49.35%)

1.26 hits per line

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

7.31

/src/Private/Context.ps1

function New-PodeContext
{
    [CmdletBinding()]
    param (
        [Parameter()]
        [scriptblock]
        $ScriptBlock,

        [Parameter()]
        [string]
        $FilePath,

        [Parameter()]
        [int]
        $Threads = 1,

        [Parameter()]
        [int]
        $Interval = 0,

        [Parameter()]
        [string]
        $ServerRoot,

        [Parameter()]
        [string]
        $Name = $null,

        [Parameter()]
        [string]
        $ServerType
    )

    # set a random server name if one not supplied
    if (Test-IsEmpty $Name) {
        $Name = Get-PodeRandomName
    }

    # are we running in a serverless context
    $isServerless = (@('AzureFunctions', 'AwsLambda') -icontains $ServerType)

    # ensure threads are always >0, for to 1 if we're serverless
    if (($Threads -le 0) -or $isServerless) {
        $Threads = 1
    }

    # basic context object
    $ctx = New-Object -TypeName psobject |
        Add-Member -MemberType NoteProperty -Name Threads -Value $Threads -PassThru |
        Add-Member -MemberType NoteProperty -Name Timers -Value @{} -PassThru |
        Add-Member -MemberType NoteProperty -Name Schedules -Value @{} -PassThru |
        Add-Member -MemberType NoteProperty -Name RunspacePools -Value $null -PassThru |
        Add-Member -MemberType NoteProperty -Name Runspaces -Value $null -PassThru |
        Add-Member -MemberType NoteProperty -Name RunspaceState -Value $null -PassThru |
        Add-Member -MemberType NoteProperty -Name Tokens -Value @{} -PassThru |
        Add-Member -MemberType NoteProperty -Name LogsToProcess -Value $null -PassThru |
        Add-Member -MemberType NoteProperty -Name Lockable -Value $null -PassThru |
        Add-Member -MemberType NoteProperty -Name Server -Value @{} -PassThru

    # set the server name, logic and root
    $ctx.Server.Name = $Name
    $ctx.Server.Logic = $ScriptBlock
    $ctx.Server.LogicPath = $FilePath
    $ctx.Server.Interval = $Interval
    $ctx.Server.PodeModulePath = (Get-PodeModulePath)

    # basic logging setup
    $ctx.Server.Logging = @{
        Enabled = $true
        Types = @{}
    }

    # set socket details for pode server
    $ctx.Server.Sockets = @{
        Listeners = @()
        MaxConnections = 0
        Ssl = @{
            Callback = $null
            Protocols = (ConvertTo-PodeSslProtocols -Protocols @('Ssl3', 'Tls12'))
        }
        ReceiveTimeout = 100
        Queues = @{
            Connections = [System.Collections.Concurrent.ConcurrentQueue[System.Net.Sockets.SocketAsyncEventArgs]]::new()
        }
    }

    $ctx.Server.WebSockets = @{
        Enabled = $false
        Listeners = @()
        MaxConnections = 0
        Ssl = @{
            Callback = $null
            Protocols = (ConvertTo-PodeSslProtocols -Protocols @('Ssl3', 'Tls12'))
        }
        ReceiveTimeout = 100
        Queues = @{
            Sockets = @{}
            Messages = [System.Collections.Concurrent.ConcurrentQueue[hashtable]]::new()
            Connections = [System.Collections.Concurrent.ConcurrentQueue[System.Net.Sockets.SocketAsyncEventArgs]]::new()
        }
    }

    # check if there is any global configuration
    $ctx.Server.Configuration = Open-PodeConfiguration -ServerRoot $ServerRoot -Context $ctx

    # configure the server's root path
    $ctx.Server.Root = $ServerRoot
    if (!(Test-IsEmpty $ctx.Server.Configuration.Server.Root)) {
        $ctx.Server.Root = Get-PodeRelativePath -Path $ctx.Server.Configuration.Server.Root -RootPath $ctx.Server.Root -JoinRoot -Resolve -TestPath
    }

    # set the server default type
    $ctx.Server.Type = $ServerType.ToUpperInvariant()
    if ($Interval -gt 0) {
        $ctx.Server.Type = 'SERVICE'
    }

    if ($isServerless) {
        $ctx.Server.IsServerless = $isServerless
    }

    # set the IP address details
    $ctx.Server.Endpoints = @()

    # general encoding for the server
    $ctx.Server.Encoding = New-Object System.Text.UTF8Encoding

    # setup gui details
    $ctx.Server.Gui = @{}

    # shared temp drives
    $ctx.Server.Drives = @{}
    $ctx.Server.InbuiltDrives = @{}

    # shared state between runspaces
    $ctx.Server.State = @{}

    # view engine for rendering pages
    $ctx.Server.ViewEngine = @{
        Type = 'html'
        Extension = 'html'
        Script = $null
        IsDynamic = $false
    }

    # routes for pages and api
    $ctx.Server.Routes = @{
        'delete' = @{};
        'get' = @{};
        'head' = @{};
        'merge' = @{};
        'options' = @{};
        'patch' = @{};
        'post' = @{};
        'put' = @{};
        'trace' = @{};
        'static' = @{};
        '*' = @{};
    }

    # handlers for tcp
    $ctx.Server.Handlers = @{
        'tcp' = @{};
        'smtp' = @{};
        'service' = @{};
    }

    # setup basic access placeholders
    $ctx.Server.Access = @{
        Allow = @{}
        Deny = @{}
    }

    # setup basic limit rules
    $ctx.Server.Limits = @{
        Rules = @{}
        Active = @{}
    }

    # cookies and session logic
    $ctx.Server.Cookies = @{
        Session = @{}
        Csrf = @{}
        Secrets = @{}
    }

    # authnetication methods
    $ctx.Server.Authentications = @{}

    # create new cancellation tokens
    $ctx.Tokens = @{
        Cancellation = New-Object System.Threading.CancellationTokenSource
        Restart = New-Object System.Threading.CancellationTokenSource
    }

    # requests that should be logged
    $ctx.LogsToProcess = New-Object System.Collections.ArrayList

    # middleware that needs to run
    $ctx.Server.Middleware = @()
    $ctx.Server.BodyParsers = @{}

    # endware that needs to run
    $ctx.Server.Endware = @()

    # runspace pools
    $ctx.RunspacePools = @{
        Main = $null
        Signals = $null
        Schedules = $null
        Gui = $null
    }

    # session state
    $ctx.Lockable = [hashtable]::Synchronized(@{})

    # setup runspaces
    $ctx.Runspaces = @()

    # return the new context
    return $ctx
}

function New-PodeRunspaceState
{
    $state = [initialsessionstate]::CreateDefault()
    $state.ImportPSModule($PodeContext.Server.PodeModulePath)

    $session = New-PodeStateContext -Context $PodeContext

    $variables = @(
        (New-Object System.Management.Automation.Runspaces.SessionStateVariableEntry -ArgumentList 'PodeContext', $session, $null),
        (New-Object System.Management.Automation.Runspaces.SessionStateVariableEntry -ArgumentList 'Console', $Host, $null),
        (New-Object System.Management.Automation.Runspaces.SessionStateVariableEntry -ArgumentList 'PODE_SCOPE_RUNSPACE', $true, $null)
    )

    foreach ($var in $variables) {
        $state.Variables.Add($var)
    }

    $PodeContext.RunspaceState = $state
}

function New-PodeRunspacePools
{
    if ($PodeContext.Server.IsServerless) {
        return
    }

    # setup main runspace pool
    $threadsCounts = @{
        Default = 3
        Timer = 1
        Log = 1
        Schedule = 1
        Misc = 1
    }

    $totalThreadCount = ($threadsCounts.Values | Measure-Object -Sum).Sum + $PodeContext.Threads
    $PodeContext.RunspacePools.Main = [runspacefactory]::CreateRunspacePool(1, $totalThreadCount, $PodeContext.RunspaceState, $Host)
    $PodeContext.RunspacePools.Main.Open()

    # setup signal runspace pool
    $PodeContext.RunspacePools.Signals = [runspacefactory]::CreateRunspacePool(1, ($PodeContext.Threads + 2), $PodeContext.RunspaceState, $Host)
    $PodeContext.RunspacePools.Signals.Open()

    # setup schedule runspace pool
    $PodeContext.RunspacePools.Schedules = [runspacefactory]::CreateRunspacePool(1, 2, $PodeContext.RunspaceState, $Host)
    $PodeContext.RunspacePools.Schedules.Open()

    # setup gui runspace pool (only for non-ps-core)
    if (!((Test-IsPSCore) -and ($PSVersionTable.PSVersion.Major -eq 6))) {
        $PodeContext.RunspacePools.Gui = [runspacefactory]::CreateRunspacePool(1, 1, $PodeContext.RunspaceState, $Host)
        $PodeContext.RunspacePools.Gui.ApartmentState = 'STA'
        $PodeContext.RunspacePools.Gui.Open()
    }
}

function New-PodeStateContext
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNull()]
        $Context
    )

    return (New-Object -TypeName psobject |
        Add-Member -MemberType NoteProperty -Name Threads -Value $Context.Threads -PassThru |
        Add-Member -MemberType NoteProperty -Name Timers -Value $Context.Timers -PassThru |
        Add-Member -MemberType NoteProperty -Name Schedules -Value $Context.Schedules -PassThru |
        Add-Member -MemberType NoteProperty -Name RunspacePools -Value $Context.RunspacePools -PassThru |
        Add-Member -MemberType NoteProperty -Name Tokens -Value $Context.Tokens -PassThru |
        Add-Member -MemberType NoteProperty -Name LogsToProcess -Value $Context.LogsToProcess -PassThru |
        Add-Member -MemberType NoteProperty -Name Lockable -Value $Context.Lockable -PassThru |
        Add-Member -MemberType NoteProperty -Name Server -Value $Context.Server -PassThru)
}

function Open-PodeConfiguration
{
    param (
        [Parameter()]
        [string]
        $ServerRoot = $null,

        [Parameter()]
        $Context
    )

    $config = @{}

    # set the path to the root config file
    $configPath = (Join-PodeServerRoot -Folder '.' -FilePath 'server.psd1' -Root $ServerRoot)

    # check to see if an environmental config exists (if the env var is set)
    if (!(Test-IsEmpty $env:PODE_ENVIRONMENT)) {
        $_path = (Join-PodeServerRoot -Folder '.' -FilePath "server.$($env:PODE_ENVIRONMENT).psd1" -Root $ServerRoot)
        if (Test-PodePath -Path $_path -NoStatus) {
            $configPath = $_path
        }
    }

    # check the path exists, and load the config
    if (Test-PodePath -Path $configPath -NoStatus) {
        $config = Import-PowerShellDataFile -Path $configPath -ErrorAction Stop
        Set-PodeServerConfiguration -Configuration $config.Server -Context $Context
        Set-PodeWebConfiguration -Configuration $config.Web -Context $Context
    }

    return $config
}

function Set-PodeServerConfiguration
{
    param (
        [Parameter()]
        [hashtable]
        $Configuration,

        [Parameter()]
        $Context
    )

    # file monitoring
    $Context.Server.FileMonitor = @{
        Enabled = ([bool]$Configuration.FileMonitor.Enable)
        Exclude = (Convert-PodePathPatternsToRegex -Paths @($Configuration.FileMonitor.Exclude))
        Include = (Convert-PodePathPatternsToRegex -Paths @($Configuration.FileMonitor.Include))
        ShowFiles = ([bool]$Configuration.FileMonitor.ShowFiles)
        Files = @()
    }

    # logging
    $Context.Server.Logging = @{
        Enabled = !([bool]$Configuration.Logging.Enable)
        Masking = @{
            Patterns = (Remove-PodeEmptyItemsFromArray -Array @($Configuration.Logging.Masking.Patterns))
            Mask = (Protect-PodeValue -Value $Configuration.Logging.Masking.Mask -Default '********')
        }
        Types = @{}
    }

    # sockets (pode)
    if (!(Test-IsEmpty $Configuration.Pode.Ssl.Protocols)) {
        $Context.Server.Sockets.Ssl.Protocols = (ConvertTo-PodeSslProtocols -Protocols $Configuration.Pode.Ssl.Protocols)
    }

    if ([int]$Configuration.Pode.ReceiveTimeout -gt 0) {
        $Context.Server.Sockets.ReceiveTimeout = (Protect-PodeValue -Value $Configuration.Pode.ReceiveTimeout $Context.Server.Sockets.ReceiveTimeout)
    }
}

function Set-PodeWebConfiguration
{
    param (
        [Parameter()]
        [hashtable]
        $Configuration,

        [Parameter()]
        $Context
    )

    # setup the main web config
    $Context.Server.Web = @{
        Static = @{
            Defaults = $Configuration.Static.Defaults
            Cache = @{
                Enabled = [bool]$Configuration.Static.Cache.Enable
                MaxAge = [int](Protect-PodeValue -Value $Configuration.Static.Cache.MaxAge -Default 3600)
                Include = (Convert-PodePathPatternsToRegex -Paths @($Configuration.Static.Cache.Include) -NotSlashes)
                Exclude = (Convert-PodePathPatternsToRegex -Paths @($Configuration.Static.Cache.Exclude) -NotSlashes)
            }
        }
        ErrorPages = @{
            ShowExceptions = [bool]$Configuration.ErrorPages.ShowExceptions
            StrictContentTyping = [bool]$Configuration.ErrorPages.StrictContentTyping
            Default = $Configuration.ErrorPages.Default
            Routes = @{}
        }
        ContentType = @{
            Default = $Configuration.ContentType.Default
            Routes = @{}
        }
    }

    # setup content type route patterns for forced content types
    $Configuration.ContentType.Routes.Keys | Where-Object { ![string]::IsNullOrWhiteSpace($_) } | ForEach-Object {
        $_type = $Configuration.ContentType.Routes[$_]
        $_pattern = (Convert-PodePathPatternToRegex -Path $_ -NotSlashes)
        $Context.Server.Web.ContentType.Routes[$_pattern] = $_type
    }

    # setup content type route patterns for error pages
    $Configuration.ErrorPages.Routes.Keys | Where-Object { ![string]::IsNullOrWhiteSpace($_) } | ForEach-Object {
        $_type = $Configuration.ErrorPages.Routes[$_]
        $_pattern = (Convert-PodePathPatternToRegex -Path $_ -NotSlashes)
        $Context.Server.Web.ErrorPages.Routes[$_pattern] = $_type
    }
}

function New-PodeAutoRestartServer
{
    # don't configure if not supplied, or running as serverless
    $config = (Get-PodeConfig)
    if (($null -eq $config) -or ($null -eq $config.Server.Restart) -or $PodeContext.Server.IsServerless)  {
        return
    }

    $restart = $config.Server.Restart

    # period - setup a timer
    $period = [int]$restart.period
    if ($period -gt 0) {
        Add-PodeTimer -Name '__pode_restart_period__' -Interval ($period * 60) -ScriptBlock {
            $PodeContext.Tokens.Restart.Cancel()
        }
    }

    # times - convert into cron expressions
    $times = @(@($restart.times) -ne $null)
    if (($times | Measure-Object).Count -gt 0) {
        $crons = @()

        @($times) | ForEach-Object {
            $atoms = $_ -split '\:'
            $crons += "$([int]$atoms[1]) $([int]$atoms[0]) * * *"
        }

        Add-PodeSchedule -Name '__pode_restart_times__' -Cron @($crons) -ScriptBlock {
            $PodeContext.Tokens.Restart.Cancel()
        }
    }

    # crons - setup schedules
    $crons = @(@($restart.crons) -ne $null)
    if (($crons | Measure-Object).Count -gt 0) {
        Add-PodeSchedule -Name '__pode_restart_crons__' -Cron @($crons) -ScriptBlock {
            $PodeContext.Tokens.Restart.Cancel()
        }
    }
}

function Get-PodeEndpoints
{
    param(
        [Parameter(Mandatory=$true)]
        [ValidateSet('Http', 'Ws')]
        [string]
        $Type
    )

    $endpoints = $null

    switch ($Type.ToLowerInvariant()) {
        'http' {
            $endpoints = @($PodeContext.Server.Endpoints | Where-Object { @('http', 'https') -icontains $_.Protocol })
        }

        'ws' {
            $endpoints = @($PodeContext.Server.Endpoints | Where-Object { @('ws', 'wss') -icontains $_.Protocol })
        }
    }

    return $endpoints
}

1	function New-PodeContext
2	{
3	[CmdletBinding()]
4	param (
5	[Parameter()]
6	[scriptblock]
7	$ScriptBlock,
8
9	[Parameter()]
10	[string]
11	$FilePath,
12
13	[Parameter()]
14	[int]
15	$Threads = 1,
16
17	[Parameter()]
18	[int]
19	$Interval = 0,
20
21	[Parameter()]
22	[string]
23	$ServerRoot,
24
25	[Parameter()]
26	[string]
27	$Name = $null,
28
29	[Parameter()]
30	[string]
31	$ServerType
32	)
33
34	# set a random server name if one not supplied
35	if (Test-IsEmpty $Name) {	×
36	$Name = Get-PodeRandomName	×
37	}
38
39	# are we running in a serverless context
40	$isServerless = (@('AzureFunctions', 'AwsLambda') -icontains $ServerType)	×
41
42	# ensure threads are always >0, for to 1 if we're serverless
43	if (($Threads -le 0) -or $isServerless) {	×
44	$Threads = 1	×
45	}
46
47	# basic context object
48	$ctx = New-Object -TypeName psobject \|	×
49	Add-Member -MemberType NoteProperty -Name Threads -Value $Threads -PassThru \|	×
50	Add-Member -MemberType NoteProperty -Name Timers -Value @{} -PassThru \|	×
51	Add-Member -MemberType NoteProperty -Name Schedules -Value @{} -PassThru \|	×
52	Add-Member -MemberType NoteProperty -Name RunspacePools -Value $null -PassThru \|	×
53	Add-Member -MemberType NoteProperty -Name Runspaces -Value $null -PassThru \|	×
54	Add-Member -MemberType NoteProperty -Name RunspaceState -Value $null -PassThru \|	×
55	Add-Member -MemberType NoteProperty -Name Tokens -Value @{} -PassThru \|	×
56	Add-Member -MemberType NoteProperty -Name LogsToProcess -Value $null -PassThru \|	×
57	Add-Member -MemberType NoteProperty -Name Lockable -Value $null -PassThru \|	×
58	Add-Member -MemberType NoteProperty -Name Server -Value @{} -PassThru	×
59
60	# set the server name, logic and root
61	$ctx.Server.Name = $Name	×
62	$ctx.Server.Logic = $ScriptBlock	×
63	$ctx.Server.LogicPath = $FilePath	×
64	$ctx.Server.Interval = $Interval	×
65	$ctx.Server.PodeModulePath = (Get-PodeModulePath)	×
66
67	# basic logging setup
68	$ctx.Server.Logging = @{	×
69	Enabled = $true	×
70	Types = @{}	×
71	}
72
73	# set socket details for pode server
74	$ctx.Server.Sockets = @{	×
75	Listeners = @()	×
76	MaxConnections = 0	×
77	Ssl = @{	×
78	Callback = $null	×
79	Protocols = (ConvertTo-PodeSslProtocols -Protocols @('Ssl3', 'Tls12'))	×
80	}
81	ReceiveTimeout = 100	×
82	Queues = @{	×
83	Connections = [System.Collections.Concurrent.ConcurrentQueue[System.Net.Sockets.SocketAsyncEventArgs]]::new()	×
84	}
85	}
86
87	$ctx.Server.WebSockets = @{	×
88	Enabled = $false	×
89	Listeners = @()	×
90	MaxConnections = 0	×
91	Ssl = @{	×
92	Callback = $null	×
93	Protocols = (ConvertTo-PodeSslProtocols -Protocols @('Ssl3', 'Tls12'))	×
94	}
95	ReceiveTimeout = 100	×
96	Queues = @{	×
97	Sockets = @{}	×
98	Messages = [System.Collections.Concurrent.ConcurrentQueue[hashtable]]::new()	×
99	Connections = [System.Collections.Concurrent.ConcurrentQueue[System.Net.Sockets.SocketAsyncEventArgs]]::new()	×
100	}
101	}
102
103	# check if there is any global configuration
104	$ctx.Server.Configuration = Open-PodeConfiguration -ServerRoot $ServerRoot -Context $ctx	×
105
106	# configure the server's root path
107	$ctx.Server.Root = $ServerRoot	×
108	if (!(Test-IsEmpty $ctx.Server.Configuration.Server.Root)) {	×
109	$ctx.Server.Root = Get-PodeRelativePath -Path $ctx.Server.Configuration.Server.Root -RootPath $ctx.Server.Root -JoinRoot -Resolve -TestPath	×
110	}
111
112	# set the server default type
113	$ctx.Server.Type = $ServerType.ToUpperInvariant()	×
114	if ($Interval -gt 0) {	×
115	$ctx.Server.Type = 'SERVICE'	×
116	}
117
118	if ($isServerless) {	×
119	$ctx.Server.IsServerless = $isServerless	×
120	}
121
122	# set the IP address details
123	$ctx.Server.Endpoints = @()	×
124
125	# general encoding for the server
126	$ctx.Server.Encoding = New-Object System.Text.UTF8Encoding	×
127
128	# setup gui details
129	$ctx.Server.Gui = @{}	×
130
131	# shared temp drives
132	$ctx.Server.Drives = @{}	×
133	$ctx.Server.InbuiltDrives = @{}	×
134
135	# shared state between runspaces
136	$ctx.Server.State = @{}	×
137
138	# view engine for rendering pages
139	$ctx.Server.ViewEngine = @{	×
140	Type = 'html'	×
141	Extension = 'html'	×
142	Script = $null	×
143	IsDynamic = $false	×
144	}
145
146	# routes for pages and api
147	$ctx.Server.Routes = @{	×
148	'delete' = @{};	×
149	'get' = @{};	×
150	'head' = @{};	×
151	'merge' = @{};	×
152	'options' = @{};	×
153	'patch' = @{};	×
154	'post' = @{};	×
155	'put' = @{};	×
156	'trace' = @{};	×
157	'static' = @{};	×
158	'*' = @{};	×
159	}
160
161	# handlers for tcp
162	$ctx.Server.Handlers = @{	×
163	'tcp' = @{};	×
164	'smtp' = @{};	×
165	'service' = @{};	×
166	}
167
168	# setup basic access placeholders
169	$ctx.Server.Access = @{	×
170	Allow = @{}	×
171	Deny = @{}	×
172	}
173
174	# setup basic limit rules
175	$ctx.Server.Limits = @{	×
176	Rules = @{}	×
177	Active = @{}	×
178	}
179
180	# cookies and session logic
181	$ctx.Server.Cookies = @{	×
182	Session = @{}	×
183	Csrf = @{}	×
184	Secrets = @{}	×
185	}
186
187	# authnetication methods
188	$ctx.Server.Authentications = @{}	×
189
190	# create new cancellation tokens
191	$ctx.Tokens = @{	×
192	Cancellation = New-Object System.Threading.CancellationTokenSource	×
193	Restart = New-Object System.Threading.CancellationTokenSource	×
194	}
195
196	# requests that should be logged
197	$ctx.LogsToProcess = New-Object System.Collections.ArrayList	×
198
199	# middleware that needs to run
200	$ctx.Server.Middleware = @()	×
201	$ctx.Server.BodyParsers = @{}	×
202
203	# endware that needs to run
204	$ctx.Server.Endware = @()	×
205
206	# runspace pools
207	$ctx.RunspacePools = @{	×
208	Main = $null	×
209	Signals = $null	×
210	Schedules = $null	×
211	Gui = $null	×
212	}
213
214	# session state
215	$ctx.Lockable = [hashtable]::Synchronized(@{})	×
216
217	# setup runspaces
218	$ctx.Runspaces = @()	×
219
220	# return the new context
221	return $ctx	×
222	}
223
224	function New-PodeRunspaceState
225	{
226	$state = [initialsessionstate]::CreateDefault()	×
227	$state.ImportPSModule($PodeContext.Server.PodeModulePath)	×
228
229	$session = New-PodeStateContext -Context $PodeContext	×
230
231	$variables = @(	×
232	(New-Object System.Management.Automation.Runspaces.SessionStateVariableEntry -ArgumentList 'PodeContext', $session, $null),	×
233	(New-Object System.Management.Automation.Runspaces.SessionStateVariableEntry -ArgumentList 'Console', $Host, $null),	×
234	(New-Object System.Management.Automation.Runspaces.SessionStateVariableEntry -ArgumentList 'PODE_SCOPE_RUNSPACE', $true, $null)	×
235	)
236
237	foreach ($var in $variables) {	×
238	$state.Variables.Add($var)	×
239	}
240
241	$PodeContext.RunspaceState = $state	×
242	}
243
244	function New-PodeRunspacePools
245	{
246	if ($PodeContext.Server.IsServerless) {	×
247	return
248	}
249
250	# setup main runspace pool
251	$threadsCounts = @{	×
252	Default = 3	×
253	Timer = 1	×
254	Log = 1	×
255	Schedule = 1	×
256	Misc = 1	×
257	}
258
259	$totalThreadCount = ($threadsCounts.Values \| Measure-Object -Sum).Sum + $PodeContext.Threads	×
260	$PodeContext.RunspacePools.Main = [runspacefactory]::CreateRunspacePool(1, $totalThreadCount, $PodeContext.RunspaceState, $Host)	×
261	$PodeContext.RunspacePools.Main.Open()	×
262
263	# setup signal runspace pool
264	$PodeContext.RunspacePools.Signals = [runspacefactory]::CreateRunspacePool(1, ($PodeContext.Threads + 2), $PodeContext.RunspaceState, $Host)	×
265	$PodeContext.RunspacePools.Signals.Open()	×
266
267	# setup schedule runspace pool
268	$PodeContext.RunspacePools.Schedules = [runspacefactory]::CreateRunspacePool(1, 2, $PodeContext.RunspaceState, $Host)	×
269	$PodeContext.RunspacePools.Schedules.Open()	×
270
271	# setup gui runspace pool (only for non-ps-core)
272	if (!((Test-IsPSCore) -and ($PSVersionTable.PSVersion.Major -eq 6))) {	×
273	$PodeContext.RunspacePools.Gui = [runspacefactory]::CreateRunspacePool(1, 1, $PodeContext.RunspaceState, $Host)	×
274	$PodeContext.RunspacePools.Gui.ApartmentState = 'STA'	×
275	$PodeContext.RunspacePools.Gui.Open()	×
276	}
277	}
278
279	function New-PodeStateContext
280	{
281	param (
282	[Parameter(Mandatory=$true)]
283	[ValidateNotNull()]
284	$Context
285	)
286
287	return (New-Object -TypeName psobject \|	×
288	Add-Member -MemberType NoteProperty -Name Threads -Value $Context.Threads -PassThru \|	×
289	Add-Member -MemberType NoteProperty -Name Timers -Value $Context.Timers -PassThru \|	×
290	Add-Member -MemberType NoteProperty -Name Schedules -Value $Context.Schedules -PassThru \|	×
291	Add-Member -MemberType NoteProperty -Name RunspacePools -Value $Context.RunspacePools -PassThru \|	×
292	Add-Member -MemberType NoteProperty -Name Tokens -Value $Context.Tokens -PassThru \|	×
293	Add-Member -MemberType NoteProperty -Name LogsToProcess -Value $Context.LogsToProcess -PassThru \|	×
294	Add-Member -MemberType NoteProperty -Name Lockable -Value $Context.Lockable -PassThru \|	×
295	Add-Member -MemberType NoteProperty -Name Server -Value $Context.Server -PassThru)	×
296	}
297
298	function Open-PodeConfiguration
299	{
300	param (
301	[Parameter()]
302	[string]
303	$ServerRoot = $null,
304
305	[Parameter()]
306	$Context
307	)
308
309	$config = @{}	×
310
311	# set the path to the root config file
312	$configPath = (Join-PodeServerRoot -Folder '.' -FilePath 'server.psd1' -Root $ServerRoot)	×
313
314	# check to see if an environmental config exists (if the env var is set)
315	if (!(Test-IsEmpty $env:PODE_ENVIRONMENT)) {	×
316	$_path = (Join-PodeServerRoot -Folder '.' -FilePath "server.$($env:PODE_ENVIRONMENT).psd1" -Root $ServerRoot)	×
317	if (Test-PodePath -Path $_path -NoStatus) {	×
318	$configPath = $_path	×
319	}
320	}
321
322	# check the path exists, and load the config
323	if (Test-PodePath -Path $configPath -NoStatus) {	×
324	$config = Import-PowerShellDataFile -Path $configPath -ErrorAction Stop	×
325	Set-PodeServerConfiguration -Configuration $config.Server -Context $Context	×
326	Set-PodeWebConfiguration -Configuration $config.Web -Context $Context	×
327	}
328
329	return $config	×
330	}
331
332	function Set-PodeServerConfiguration
333	{
334	param (
335	[Parameter()]
336	[hashtable]
337	$Configuration,
338
339	[Parameter()]
340	$Context
341	)
342
343	# file monitoring
344	$Context.Server.FileMonitor = @{	×
345	Enabled = ([bool]$Configuration.FileMonitor.Enable)	×
346	Exclude = (Convert-PodePathPatternsToRegex -Paths @($Configuration.FileMonitor.Exclude))	×
347	Include = (Convert-PodePathPatternsToRegex -Paths @($Configuration.FileMonitor.Include))	×
348	ShowFiles = ([bool]$Configuration.FileMonitor.ShowFiles)	×
349	Files = @()	×
350	}
351
352	# logging
353	$Context.Server.Logging = @{	×
354	Enabled = !([bool]$Configuration.Logging.Enable)	×
355	Masking = @{	×
356	Patterns = (Remove-PodeEmptyItemsFromArray -Array @($Configuration.Logging.Masking.Patterns))	×
357	Mask = (Protect-PodeValue -Value $Configuration.Logging.Masking.Mask -Default '********')	×
358	}
359	Types = @{}	×
360	}
361
362	# sockets (pode)
363	if (!(Test-IsEmpty $Configuration.Pode.Ssl.Protocols)) {	×
364	$Context.Server.Sockets.Ssl.Protocols = (ConvertTo-PodeSslProtocols -Protocols $Configuration.Pode.Ssl.Protocols)	×
365	}
366
367	if ([int]$Configuration.Pode.ReceiveTimeout -gt 0) {	×
368	$Context.Server.Sockets.ReceiveTimeout = (Protect-PodeValue -Value $Configuration.Pode.ReceiveTimeout $Context.Server.Sockets.ReceiveTimeout)	×
369	}
370	}
371
372	function Set-PodeWebConfiguration
373	{
374	param (
375	[Parameter()]
376	[hashtable]
377	$Configuration,
378
379	[Parameter()]
380	$Context
381	)
382
383	# setup the main web config
384	$Context.Server.Web = @{	×
385	Static = @{	×
386	Defaults = $Configuration.Static.Defaults	×
387	Cache = @{	×
388	Enabled = [bool]$Configuration.Static.Cache.Enable	×
389	MaxAge = [int](Protect-PodeValue -Value $Configuration.Static.Cache.MaxAge -Default 3600)	×
390	Include = (Convert-PodePathPatternsToRegex -Paths @($Configuration.Static.Cache.Include) -NotSlashes)	×
391	Exclude = (Convert-PodePathPatternsToRegex -Paths @($Configuration.Static.Cache.Exclude) -NotSlashes)	×
392	}
393	}
394	ErrorPages = @{	×
395	ShowExceptions = [bool]$Configuration.ErrorPages.ShowExceptions	×
396	StrictContentTyping = [bool]$Configuration.ErrorPages.StrictContentTyping	×
397	Default = $Configuration.ErrorPages.Default	×
398	Routes = @{}	×
399	}
400	ContentType = @{	×
401	Default = $Configuration.ContentType.Default	×
402	Routes = @{}	×
403	}
404	}
405
406	# setup content type route patterns for forced content types
407	$Configuration.ContentType.Routes.Keys \| Where-Object { ![string]::IsNullOrWhiteSpace($_) } \| ForEach-Object {	×
408	$_type = $Configuration.ContentType.Routes[$_]	×
409	$_pattern = (Convert-PodePathPatternToRegex -Path $_ -NotSlashes)	×
410	$Context.Server.Web.ContentType.Routes[$_pattern] = $_type	×
411	}
412
413	# setup content type route patterns for error pages
414	$Configuration.ErrorPages.Routes.Keys \| Where-Object { ![string]::IsNullOrWhiteSpace($_) } \| ForEach-Object {	×
415	$_type = $Configuration.ErrorPages.Routes[$_]	×
416	$_pattern = (Convert-PodePathPatternToRegex -Path $_ -NotSlashes)	×
417	$Context.Server.Web.ErrorPages.Routes[$_pattern] = $_type	×
418	}
419	}
420
421	function New-PodeAutoRestartServer
422	{
423	# don't configure if not supplied, or running as serverless
424	$config = (Get-PodeConfig)	4✔
425	if (($null -eq $config) -or ($null -eq $config.Server.Restart) -or $PodeContext.Server.IsServerless) {	6✔
426	return
427	}
428
429	$restart = $config.Server.Restart	2✔
430
431	# period - setup a timer
432	$period = [int]$restart.period	2✔
433	if ($period -gt 0) {	2✔
434	Add-PodeTimer -Name '__pode_restart_period__' -Interval ($period * 60) -ScriptBlock {	4✔
435	$PodeContext.Tokens.Restart.Cancel()	×
436	}
437	}
438
439	# times - convert into cron expressions
440	$times = @(@($restart.times) -ne $null)	6✔
441	if (($times \| Measure-Object).Count -gt 0) {	6✔
442	$crons = @()	2✔
443
444	@($times) \| ForEach-Object {	6✔
445	$atoms = $_ -split '\:'	2✔
446	$crons += "$([int]$atoms[1]) $([int]$atoms[0]) * * *"	6✔
447	}
448
449	Add-PodeSchedule -Name '__pode_restart_times__' -Cron @($crons) -ScriptBlock {	4✔
450	$PodeContext.Tokens.Restart.Cancel()	×
451	}
452	}
453
454	# crons - setup schedules
455	$crons = @(@($restart.crons) -ne $null)	6✔
456	if (($crons \| Measure-Object).Count -gt 0) {	6✔
457	Add-PodeSchedule -Name '__pode_restart_crons__' -Cron @($crons) -ScriptBlock {	4✔
458	$PodeContext.Tokens.Restart.Cancel()	×
459	}
460	}
461	}
462
463	function Get-PodeEndpoints
464	{
465	param(
466	[Parameter(Mandatory=$true)]
467	[ValidateSet('Http', 'Ws')]
468	[string]
469	$Type
470	)
471
472	$endpoints = $null	×
473
474	switch ($Type.ToLowerInvariant()) {	×
475	'http' {
476	$endpoints = @($PodeContext.Server.Endpoints \| Where-Object { @('http', 'https') -icontains $_.Protocol })	×
477	}
478
479	'ws' {
480	$endpoints = @($PodeContext.Server.Endpoints \| Where-Object { @('ws', 'wss') -icontains $_.Protocol })	×
481	}
482	}
483
484	return $endpoints	×
485	}

Badgerati / Pode / #489

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