#652

pending completion

Build # #652

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/69c940e991daa5031d5bfe35d71446d247d32ccd">69c940e99">&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/69c940e991daa5031d5bfe35d71446d247d32ccd">69c940e99</a><a href="https://github.com/Badgerati/Pode/commit/69c940e991daa5031d5bfe35d71446d247d32ccd">&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/69c940e991daa5031d5bfe35d71446d247d32ccd&quot;&gt;69c940e99&lt;/a&gt;&lt;a href=&quot;https://github.com/Badgerati/Pode/commit/69c940e991daa5031d5bfe35d71446d247d32ccd&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

16 of 16 new or added lines in 5 files covered. (100.0%)

2718 of 5990 relevant lines covered (45.38%)

1.17 hits per line

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

6.69

/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,

        [Parameter()]
        [string]
        $StatusPageExceptions,

        [switch]
        $DisableTermination,

        [switch]
        $Quiet
    )

    # 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, and other basic properties
    $ctx.Server.Name = $Name
    $ctx.Server.Logic = $ScriptBlock
    $ctx.Server.LogicPath = $FilePath
    $ctx.Server.Interval = $Interval
    $ctx.Server.PodeModulePath = (Get-PodeModulePath)
    $ctx.Server.DisableTermination = $DisableTermination.IsPresent
    $ctx.Server.Quiet = $Quiet.IsPresent

    # 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

    # over status page exceptions
    if (!(Test-IsEmpty $StatusPageExceptions)) {
        if ($null -eq $ctx.Server.Web) {
            $ctx.Server.Web = @{ ErrorPages = @{} }
        }

        $ctx.Server.Web.ErrorPages.ShowExceptions = ($StatusPageExceptions -eq 'show')
    }

    # 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 it's serverless, also disable termination
    if ($isServerless) {
        $ctx.Server.IsServerless = $isServerless
        $ctx.Server.DisableTermination = $true
    }

    # is the server running under IIS? (also, force the server type to pode, and disable termination)
    $ctx.Server.IsIIS = (!$isServerless -and (!(Test-IsEmpty $env:ASPNETCORE_PORT)) -and (!(Test-IsEmpty $env:ASPNETCORE_TOKEN)))
    if ($ctx.Server.IsIIS) {
        $ctx.Server.Type = 'PODE'
        $ctx.Server.DisableTermination = $true

        # if under IIS and Azure Web App, force quiet
        if (!(Test-IsEmpty $env:WEBSITE_IIS_SITE_NAME)) {
            $ctx.Server.Quiet = $true
        }
    }

    # is the server running under Heroku?
    $ctx.Server.IsHeroku = (!$isServerless -and (!(Test-IsEmpty $env:PORT)) -and (!(Test-IsEmpty $env:DYNO)))

    # if we're inside a remote host, stop termination
    if ($Host.Name -ieq 'ServerRemoteHost') {
        $ctx.Server.DisableTermination = $true
    }

    # 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
        }
        Requests = @{
            Total = 0
            StatusCodes = @{}
        }
    }

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

    # common support values
    $ctx.Server.Compression = @{
        Encodings = @('gzip', 'deflate', 'x-gzip')
    }

    # 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 = @{}
        }
        TransferEncoding = @{
            Default = $Configuration.TransferEncoding.Default
            Routes = @{}
        }
        Compression = @{
            Enabled = [bool]$Configuration.Compression.Enable
        }
    }

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

Badgerati / Pode / #652

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