#438

pending completion

Build # #438

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/05be925dcc8e8b18a4a3de0435c13a43a603abcc">05be925dc<a href="https://github.com/Badgerati/Pode/commit/05be925dcc8e8b18a4a3de0435c13a43a603abcc">">Merge </a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/<a class="double-link" href="https://github.com/Badgerati/Pode/commit/81d7a8494087ffbb21ba12efe44ebc5c5c32649a">81d7a8494</a>">81d7a8494</a><a href="https://github.com/Badgerati/Pode/commit/05be925dcc8e8b18a4a3de0435c13a43a603abcc"> into b10be3a2d">b10be3a2d</a>

Run Details

364 of 364 new or added lines in 13 files covered. (100.0%)

2246 of 4379 relevant lines covered (51.29%)

1.31 hits per line

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

8.08

/src/Private/Context.ps1

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

        [int]
        $Threads = 1,

        [int]
        $Interval = 0,

        [string]
        $ServerRoot,

        [string]
        $Name = $null,

        [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.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 = @{
            Contexts = [System.Collections.Generic.List[hashtable]]::new(100)
            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 = @()

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

    # runspace pools
    $ctx.RunspacePools = @{
        Main = $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 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()
        }
    }
}

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

Badgerati / Pode / #438

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