#536

pending completion

Build # #536

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/<a class="double-link" href="https://git"><a class=hub.com/Badgerati/Pode/commit/<a class="double-link" href="https://git"><a class=hub.com/Badgerati/Pode/commit/<a class="double-link" href="https://git"><a class=hub.com/Badgerati/Pode/commit/3af17c492d0ce3b762a4eb58b7036f1731449600">3af17c492">&lt;a href=&quot;https://github.com/Badgerati/Pode/commit/</a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Badgerati/Pode/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Badgerati/Pode/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Badgerati/Pode/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Badgerati/Pode/commit/3af17c492d0ce3b762a4eb58b7036f1731449600">3af17c492</a><a href="https://github.com/Badgerati/Pode/commit/3af17c492d0ce3b762a4eb58b7036f1731449600">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/Badgerati/Pode/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/Badgerati/Pode/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Badgerati/Pode/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Badgerati/Pode/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Badgerati/Pode/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Badgerati/Pode/commit/3af17c492d0ce3b762a4eb58b7036f1731449600&quot;&gt;3af17c492&lt;/a&gt;&lt;a href=&quot;https://github.com/Badgerati/Pode/commit/3af17c492d0ce3b762a4eb58b7036f1731449600&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/Badgerati/Pode/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/Badgerati/Pode/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=... (continued)

Run Details

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

2358 of 5104 relevant lines covered (46.2%)

1.19 hits per line

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

7.53

/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 @{} -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 |
        Add-Member -MemberType NoteProperty -Name Metrics -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 thread counts
    $ctx.Threads = @{
        Web = $Threads
        Schedules = 10
    }

    # 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 = @{
        Csrf = @{}
        Secrets = @{}
    }

    # sessions
    $ctx.Server.Sessions = @{}

    # swagger and openapi
    $ctx.Server.OpenAPI = @{
        Path = $null
        Title = $null
        components = @{
            schemas = @{}
            responses = @{}
            securitySchemas = @{}
            requestBodies = @{}
            parameters = @{}
        }
        security = @()
    }

    # server metrics
    $ctx.Metrics = @{
        Server = @{
            InitialLoadTime = [datetime]::UtcNow
            StartTime = [datetime]::UtcNow
            RestartCount = 0
        }
    }

    # 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.Web
    $PodeContext.RunspacePools.Main = [runspacefactory]::CreateRunspacePool(1, $totalThreadCount, $PodeContext.RunspaceState, $Host)

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

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

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

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

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

Badgerati / Pode / #536

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