Downloads:
15,566
Downloads of v 2.1.1:
116
Last Update:
19 Feb 2021
Package Maintainer(s):
Software Author(s):
- Badgerati
Tags:
powershell web server rest api http tcp smtp listener unix cross-platform file-monitoring multithreaded schedule middleware session authentication active-directory csrf lambda aws azure functions websockets openapi swagger redoc- Software Specific:
- Software Site
- Software License
- Software Docs
- Software Issues
- Package Specific:
- Package Source
- Package outdated?
- Package broken?
- Contact Maintainers
- Contact Site Admins
- Software Vendor?
- Report Abuse
- Download
Pode
This is not the latest version of Pode available.
- 1
- 2
- 3
2.1.1 | Updated: 19 Feb 2021
- Software Specific:
- Software Site
- Software License
- Software Docs
- Software Issues
- Package Specific:
- Package Source
- Package outdated?
- Package broken?
- Contact Maintainers
- Contact Site Admins
- Software Vendor?
- Report Abuse
- Download
Downloads:
15,566
Downloads of v 2.1.1:
116
Maintainer(s):
Software Author(s):
- Badgerati
Pode 2.1.1
This is not the latest version of Pode available.
- 1
- 2
- 3
Some Checks Have Failed or Are Not Yet Complete
Not All Tests Have Passed
Validation Testing Passed
Verification Testing Passed
DetailsScan Testing Resulted in Flagged:
This package was submitted (and approved) prior to automated virus scanning integration into the package moderation processs.
We recommend clicking the "Details" link to make your own decision on installing this package.
Deployment Method: Individual Install, Upgrade, & Uninstall
To install Pode, run the following command from the command line or from PowerShell:
To upgrade Pode, run the following command from the command line or from PowerShell:
To uninstall Pode, run the following command from the command line or from PowerShell:
Deployment Method:
This applies to both open source and commercial editions of Chocolatey.
1. Enter Your Internal Repository Url
(this should look similar to https://community.chocolatey.org/api/v2/)
2. Setup Your Environment
1. Ensure you are set for organizational deployment
Please see the organizational deployment guide
2. Get the package into your environment
Option 1: Cached Package (Unreliable, Requires Internet - Same As Community)-
Open Source or Commercial:
- Proxy Repository - Create a proxy nuget repository on Nexus, Artifactory Pro, or a proxy Chocolatey repository on ProGet. Point your upstream to https://community.chocolatey.org/api/v2/. Packages cache on first access automatically. Make sure your choco clients are using your proxy repository as a source and NOT the default community repository. See source command for more information.
- You can also just download the package and push it to a repository Download
-
Open Source
-
Download the package:
Download - Follow manual internalization instructions
-
-
Package Internalizer (C4B)
-
Run: (additional options)
choco download pode --internalize --version=2.1.1 --source=https://community.chocolatey.org/api/v2/
-
For package and dependencies run:
choco push --source="'INTERNAL REPO URL'"
- Automate package internalization
-
Run: (additional options)
3. Copy Your Script
choco upgrade pode -y --source="'INTERNAL REPO URL'" --version="'2.1.1'" [other options]
See options you can pass to upgrade.
See best practices for scripting.
Add this to a PowerShell script or use a Batch script with tools and in places where you are calling directly to Chocolatey. If you are integrating, keep in mind enhanced exit codes.
If you do use a PowerShell script, use the following to ensure bad exit codes are shown as failures:
choco upgrade pode -y --source="'INTERNAL REPO URL'" --version="'2.1.1'"
$exitCode = $LASTEXITCODE
Write-Verbose "Exit code was $exitCode"
$validExitCodes = @(0, 1605, 1614, 1641, 3010)
if ($validExitCodes -contains $exitCode) {
Exit 0
}
Exit $exitCode
- name: Install pode
win_chocolatey:
name: pode
version: '2.1.1'
source: INTERNAL REPO URL
state: present
See docs at https://docs.ansible.com/ansible/latest/modules/win_chocolatey_module.html.
chocolatey_package 'pode' do
action :install
source 'INTERNAL REPO URL'
version '2.1.1'
end
See docs at https://docs.chef.io/resource_chocolatey_package.html.
cChocoPackageInstaller pode
{
Name = "pode"
Version = "2.1.1"
Source = "INTERNAL REPO URL"
}
Requires cChoco DSC Resource. See docs at https://github.com/chocolatey/cChoco.
package { 'pode':
ensure => '2.1.1',
provider => 'chocolatey',
source => 'INTERNAL REPO URL',
}
Requires Puppet Chocolatey Provider module. See docs at https://forge.puppet.com/puppetlabs/chocolatey.
4. If applicable - Chocolatey configuration/installation
See infrastructure management matrix for Chocolatey configuration elements and examples.
This package was approved by moderator TheCakeIsNaOH on 27 Feb 2021.
Pode is a Cross-Platform framework for creating web servers to host REST APIs and Websites. Pode also has support for being used in Azure Functions and AWS Lambda.
Features
- Cross-platform using PowerShell Core (with support for PS5)
- Docker support, including images for ARM/Raspberry Pi
- Azure Functions, AWS Lambda, and IIS support
- OpenAPI, Swagger, and ReDoc support
- Listen on a single or multiple IP address/hostnames
- Cross-platform support for HTTP, HTTPS, TCP and SMTP
- Cross-platform support for server-to-client WebSockets, including secure WebSockets
- Host REST APIs, Web Pages, and Static Content (with caching)
- Support for custom error pages
- Request and Response compression using GZip/Deflate
- Multi-thread support for incoming requests
- Inbuilt template engine, with support for third-parties
- Async timers for short-running repeatable processes
- Async scheduled tasks using cron expressions for short/long-running processes
- Supports logging to CLI, Files, and custom logic for other services like LogStash
- Cross-state variable access across multiple runspaces
- Restart the server via file monitoring, or defined periods/times
- Ability to allow/deny requests from certain IP addresses and subnets
- Basic rate limiting for IP addresses and subnets
- Middleware and Sessions on web servers, with Flash message and CSRF support
- Authentication on requests, such as Basic, Windows and Azure AD
- Support for dynamically building Routes from Functions and Modules
- Generate/bind self-signed certificates
- (Windows) Open the hosted server as a desktop application
{
"runtimeTarget": {
"name": ".NETStandard,Version=v2.0/",
"signature": ""
},
"compilationOptions": {},
"targets": {
".NETStandard,Version=v2.0": {},
".NETStandard,Version=v2.0/": {
"Pode/1.0.0": {
"dependencies": {
"NETStandard.Library": "2.0.3"
},
"runtime": {
"Pode.dll": {}
}
},
"Microsoft.NETCore.Platforms/1.1.0": {},
"NETStandard.Library/2.0.3": {
"dependencies": {
"Microsoft.NETCore.Platforms": "1.1.0"
}
}
}
},
"libraries": {
"Pode/1.0.0": {
"type": "project",
"serviceable": false,
"sha512": ""
},
"Microsoft.NETCore.Platforms/1.1.0": {
"type": "package",
"serviceable": true,
"sha512": "sha512-kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A==",
"path": "microsoft.netcore.platforms/1.1.0",
"hashPath": "microsoft.netcore.platforms.1.1.0.nupkg.sha512"
},
"NETStandard.Library/2.0.3": {
"type": "package",
"serviceable": true,
"sha512": "sha512-st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
"path": "netstandard.library/2.0.3",
"hashPath": "netstandard.library.2.0.3.nupkg.sha512"
}
}
}
md5: 21264B47567AF3F436E4DF2739BC8BEB | sha1: 3BF3B905F78C3BC1C4B90D5C96D7A0D253EDC51B | sha256: B373939FE6CEE26710348C32E668509AF41A014ACAC9B7CF289BAC51A2F9C399 | sha512: 303180B7CC2414570A182902A03233D5739072B1A74752489F8664D879E0F5EA2516CA5C83A2935AB1853A3D5D1A218284BEE31EC6688BDD7C9A4BFB7F6475D7
The MIT License (MIT)
Copyright (c) [2017-2021] [Matthew Kelly (Badgerati)]
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
#
# Module manifest for module 'Pode'
#
# Generated by: Matthew Kelly (Badgerati)
#
# Generated on: 28/11/2017
#
@{
# Script module or binary module file associated with this manifest.
RootModule = 'Pode.psm1'
# Version number of this module.
ModuleVersion = '2.1.1'
# ID used to uniquely identify this module
GUID = 'e3ea217c-fc3d-406b-95d5-4304ab06c6af'
# Author of this module
Author = 'Matthew Kelly (Badgerati)'
# Copyright statement for this module
Copyright = 'Copyright (c) 2017-2021 Matthew Kelly (Badgerati), licensed under the MIT License.'
# Description of the functionality provided by this module
Description = 'A Cross-Platform PowerShell framework for creating web servers to host REST APIs and Websites. Pode also has support for being used in Azure Functions and AWS Lambda.'
# Minimum version of the Windows PowerShell engine required by this module
PowerShellVersion = '5.0'
# Assemblies that must be loaded prior to importing this module
RequiredAssemblies = @(
'System.Web',
'System.Net.Http',
'./Libs/Pode.dll'
)
# Functions to export from this Module
FunctionsToExport = @(
# cookies
'Get-PodeCookie',
'Get-PodeCookieSecret',
'Remove-PodeCookie',
'Set-PodeCookie',
'Set-PodeCookieSecret',
'Test-PodeCookie',
'Test-PodeCookieSigned',
'Update-PodeCookieExpiry',
# flash
'Add-PodeFlashMessage',
'Clear-PodeFlashMessages',
'Get-PodeFlashMessage',
'Get-PodeFlashMessageNames',
'Remove-PodeFlashMessage',
'Test-PodeFlashMessage',
# headers
'Add-PodeHeader',
'Test-PodeHeader',
'Get-PodeHeader',
'Set-PodeHeader',
'Test-PodeHeaderSigned',
# state
'Set-PodeState',
'Get-PodeState',
'Remove-PodeState',
'Save-PodeState',
'Restore-PodeState',
'Test-PodeState',
# response helpers
'Set-PodeResponseAttachment',
'Write-PodeTextResponse',
'Write-PodeFileResponse',
'Write-PodeCsvResponse',
'Write-PodeHtmlResponse',
'Write-PodeMarkdownResponse',
'Write-PodeJsonResponse',
'Write-PodeXmlResponse',
'Write-PodeViewResponse',
'Set-PodeResponseStatus',
'Move-PodeResponseUrl',
'Write-PodeTcpClient',
'Read-PodeTcpClient',
'Save-PodeRequestFile',
'Set-PodeViewEngine',
'Use-PodePartialView',
'Send-PodeSignal',
'Add-PodeViewFolder',
# utility helpers
'Wait-PodeTask',
'Close-PodeDisposable',
'Lock-PodeObject',
'Get-PodeServerPath',
'Start-PodeStopwatch',
'Use-PodeStream',
'Use-PodeScript',
'Get-PodeConfig',
'Add-PodeEndware',
'Import-PodeModule',
'Import-PodeSnapIn',
'Protect-PodeValue',
'Resolve-PodeValue',
'Invoke-PodeScriptBlock',
'Test-PodeIsUnix',
'Test-PodeIsWindows',
'Test-PodeIsPSCore',
'Test-PodeIsEmpty',
'Out-PodeHost',
'Write-PodeHost',
'Test-PodeIsIIS',
'Test-PodeIsHeroku',
# routes
'Add-PodeRoute',
'Add-PodeStaticRoute',
'Remove-PodeRoute',
'Remove-PodeStaticRoute',
'Clear-PodeRoutes',
'Clear-PodeStaticRoutes',
'ConvertTo-PodeRoute',
'Add-PodePage',
'Get-PodeRoute',
'Get-PodeStaticRoute',
# handlers
'Add-PodeHandler',
'Remove-PodeHandler',
'Clear-PodeHandlers',
# schedules
'Add-PodeSchedule',
'Remove-PodeSchedule',
'Clear-PodeSchedule',
'Invoke-PodeSchedule',
'Edit-PodeSchedule',
'Set-PodeScheduleConcurrency',
'Get-PodeSchedule',
'Get-PodeScheduleNextTrigger',
# timers
'Add-PodeTimer',
'Remove-PodeTimer',
'Clear-PodeTimers',
'Invoke-PodeTimer',
'Edit-PodeTimer',
'Get-PodeTimer',
# middleware
'Add-PodeMiddleware',
'Remove-PodeMiddleware',
'Clear-PodeMiddleware',
'Add-PodeAccessRule',
'Add-PodeLimitRule',
'Enable-PodeSessionMiddleware',
'New-PodeCsrfToken',
'Get-PodeCsrfMiddleware',
'Initialize-PodeCsrf',
'Enable-PodeCsrfMiddleware',
'Remove-PodeSession',
'Save-PodeSession',
'Get-PodeSessionId',
# auth
'New-PodeAuthScheme',
'New-PodeAuthAzureADScheme',
'Add-PodeAuth',
'Get-PodeAuth',
'Clear-PodeAuth',
'Add-PodeAuthWindowsAd',
'Add-PodeAuthWindowsLocal',
'Remove-PodeAuth',
'Add-PodeAuthMiddleware',
'Add-PodeAuthIIS',
'Add-PodeAuthUserFile',
# logging
'New-PodeLoggingMethod',
'Enable-PodeRequestLogging',
'Enable-PodeErrorLogging',
'Disable-PodeRequestLogging',
'Disable-PodeErrorLogging',
'Add-PodeLogger',
'Remove-PodeLogger',
'Clear-PodeLoggers',
'Write-PodeErrorLog',
'Write-PodeLog',
'Protect-PodeLogItem',
# core
'Start-PodeServer',
'Close-PodeServer',
'Start-PodeStaticServer',
'Show-PodeGui',
'Add-PodeEndpoint',
'Get-PodeEndpoint',
'Pode',
# openapi
'Enable-PodeOpenApi',
'Get-PodeOpenApiDefinition',
'Add-PodeOAResponse',
'Remove-PodeOAResponse',
'Add-PodeOAComponentResponse',
'Set-PodeOARequest',
'New-PodeOARequestBody',
'Add-PodeOAComponentSchema',
'Add-PodeOAComponentRequestBody',
'Add-PodeOAComponentParameter',
'New-PodeOAIntProperty',
'New-PodeOANumberProperty',
'New-PodeOAStringProperty',
'New-PodeOABoolProperty',
'New-PodeOAObjectProperty',
'ConvertTo-PodeOAParameter',
'Set-PodeOARouteInfo',
'Enable-PodeOpenApiViewer',
# Metrics
'Get-PodeServerUptime',
'Get-PodeServerRestartCount',
'Get-PodeServerRequestMetric',
# AutoImport
'Export-PodeModule',
'Export-PodeSnapin',
'Export-PodeFunction'
)
# Private data to pass to the module specified in RootModule/ModuleToProcess. This may also contain a PSData hashtable with additional module metadata used by PowerShell.
PrivateData = @{
PSData = @{
# Tags applied to this module. These help with module discovery in online galleries.
Tags = @('powershell', 'web', 'server', 'http', 'listener', 'rest', 'api', 'tcp', 'smtp', 'websites',
'powershell-core', 'windows', 'unix', 'linux', 'pode', 'PSEdition_Core', 'cross-platform', 'access-control',
'file-monitoring', 'multithreaded', 'rate-limiting', 'cron', 'schedule', 'middleware', 'session',
'authentication', 'active-directory', 'caching', 'csrf', 'arm', 'raspberry-pi', 'aws-lambda',
'azure-functions', 'websockets', 'swagger', 'openapi', 'redoc')
# A URL to the license for this module.
LicenseUri = 'https://raw.githubusercontent.com/Badgerati/Pode/master/LICENSE.txt'
# A URL to the main website for this project.
ProjectUri = 'https://github.com/Badgerati/Pode'
# A URL to an icon representing this module.
IconUri = 'https://cdn.rawgit.com/Badgerati/Pode/master/images/icon.png'
# Release notes for this particular version of the module
ReleaseNotes = 'https://github.com/Badgerati/Pode/releases/tag/v2.1.1'
}
}
}
# root path
$root = Split-Path -Parent -Path $MyInvocation.MyCommand.Path
# load binaries
Add-Type -AssemblyName System.Web
Add-Type -AssemblyName System.Net.Http
Add-Type -LiteralPath "$($root)/Libs/Pode.dll"
# import everything if in a runspace
if ($PODE_SCOPE_RUNSPACE) {
$sysfuncs = Get-ChildItem Function:
}
# load private functions
Get-ChildItem "$($root)/Private/*.ps1" | Resolve-Path | ForEach-Object { . $_ }
# only import public functions if not in a runspace
if (!$PODE_SCOPE_RUNSPACE) {
$sysfuncs = Get-ChildItem Function:
}
# load public functions
Get-ChildItem "$($root)/Public/*.ps1" | Resolve-Path | ForEach-Object { . $_ }
# get functions from memory and compare to existing to find new functions added
$funcs = Get-ChildItem Function: | Where-Object { $sysfuncs -notcontains $_ }
# export the module's public functions
Export-ModuleMember -Function ($funcs.Name)
function Get-PodeAuthBasicType
{
return {
param($options)
# get the auth header
$header = (Get-PodeHeader -Name 'Authorization')
if ($null -eq $header) {
return @{
Message = 'No Authorization header found'
Code = 401
}
}
# ensure the first atom is basic (or opt override)
$atoms = $header -isplit '\s+'
if ($atoms.Length -lt 2) {
return @{
Message = 'Invalid Authorization header'
Code = 400
}
}
if ($atoms[0] -ine $options.HeaderTag) {
return @{
Message = "Header is not for $($options.HeaderTag) Authorization"
Code = 400
}
}
# decode the auth header
try {
$enc = [System.Text.Encoding]::GetEncoding($options.Encoding)
}
catch {
return @{
Message = 'Invalid encoding specified for Authorization'
Code = 400
}
}
try {
$decoded = $enc.GetString([System.Convert]::FromBase64String($atoms[1]))
}
catch {
return @{
Message = 'Invalid Base64 string found in Authorization header'
Code = 400
}
}
# validate and return user/result
$index = $decoded.IndexOf(':')
$username = $decoded.Substring(0, $index)
$password = $decoded.Substring($index + 1)
# return data for calling validator
return @($username, $password)
}
}
function Get-PodeAuthOAuth2Type
{
return {
param($options, $schemes)
# set default scopes
if (($null -eq $options.Scopes) -or ($options.Scopes.Length -eq 0)) {
$options.Scopes = @('openid', 'profile', 'email')
}
$scopes = ($options.Scopes -join ' ')
# if there's an error, fail
if (![string]::IsNullOrWhiteSpace($WebEvent.Query['error'])) {
return @{
Message = $WebEvent.Query['error']
Code = 401
}
}
# set grant type
$hasInnerScheme = (($null -ne $schemes) -and ($schemes.Length -gt 0))
$grantType = 'authorization_code'
if ($hasInnerScheme) {
$grantType = 'password'
}
# if there's a code query param, or inner scheme, get access token
if ($hasInnerScheme -or ![string]::IsNullOrWhiteSpace($WebEvent.Query['code'])) {
# set default query
$body = "client_id=$($options.Client.ID)"
$body += "&grant_type=$($grantType)"
$body += "&client_secret=$([System.Web.HttpUtility]::UrlEncode($options.Client.Secret))"
# if there's an inner scheme, get the username/password, and set query
if ($hasInnerScheme) {
$body += "&username=$($schemes[-1][0])"
$body += "&password=$($schemes[-1][1])"
$body += "&scope=$([System.Web.HttpUtility]::UrlEncode($scopes))"
}
# otherwise, set query for auth_code
else {
$redirectUrl = Get-PodeOAuth2RedirectHost -RedirectUrl $options.Urls.Redirect
$body += "&code=$($WebEvent.Query['code'])"
$body += "&redirect_uri=$([System.Web.HttpUtility]::UrlEncode($redirectUrl))"
}
# POST the tokenUrl
try {
$result = Invoke-RestMethod -Method Post -Uri $options.Urls.Token -Body $body -ContentType 'application/x-www-form-urlencoded' -ErrorAction Stop
}
catch [System.Net.WebException], [System.Net.Http.HttpRequestException] {
$response = Read-PodeWebExceptionDetails -ErrorRecord $_
$result = ($response.Body | ConvertFrom-Json)
}
if (![string]::IsNullOrWhiteSpace($result.error)) {
return @{
Message = "$($result.error): $($result.error_description)"
Code = 401
}
}
# get user details - if url supplied
if (![string]::IsNullOrWhiteSpace($options.Urls.User)) {
try {
$user = Invoke-RestMethod -Method Post -Uri $options.Urls.User -Headers @{ Authorization = "Bearer $($result.access_token)" }
}
catch [System.Net.WebException], [System.Net.Http.HttpRequestException] {
$response = Read-PodeWebExceptionDetails -ErrorRecord $_
$user = ($response.Body | ConvertFrom-Json)
}
if (![string]::IsNullOrWhiteSpace($user.error)) {
return @{
Message = "$($user.error): $($user.error_description)"
Code = 401
}
}
}
else {
$user = @{ Provider = 'OAuth2' }
}
# return the user for the validator
return @($user, $result.access_token, $result.refresh_token)
}
# redirect to the authUrl - only if no inner scheme supplied
if (!$hasInnerScheme) {
$redirectUrl = Get-PodeOAuth2RedirectHost -RedirectUrl $options.Urls.Redirect
$query = "client_id=$($options.Client.ID)"
$query += "&response_type=code"
$query += "&redirect_uri=$([System.Web.HttpUtility]::UrlEncode($redirectUrl))"
$query += "&response_mode=query"
$query += "&scope=$([System.Web.HttpUtility]::UrlEncode($scopes))"
Move-PodeResponseUrl -Url "$($options.Urls.Authorise)?$($query)"
return @{ IsRedirected = $true }
}
# hmm, this is unexpected
return @{ Code = 500 }
}
}
function Get-PodeOAuth2RedirectHost
{
param(
[Parameter()]
[string]
$RedirectUrl
)
if ($RedirectUrl.StartsWith('/')) {
if ($PodeContext.Server.IsIIS -or $PodeContext.Server.IsHeroku) {
$protocol = Get-PodeHeader -Name 'X-Forwarded-Proto'
if ([string]::IsNullOrWhiteSpace($protocol)) {
$protocol = 'https'
}
$domain = "$($protocol)://$($WebEvent.Request.Host)"
}
else {
$domain = Get-PodeEndpointUrl
}
$RedirectUrl = "$($domain.TrimEnd('/'))$($RedirectUrl)"
}
return $RedirectUrl
}
function Get-PodeAuthClientCertificateType
{
return {
param($options)
$cert = $WebEvent.Request.ClientCertificate
# ensure we have a client cert
if ($null -eq $cert) {
return @{
Message = 'No client certificate supplied'
Code = 401
}
}
# ensure the cert has a thumbprint
if ([string]::IsNullOrWhiteSpace($cert.Thumbprint)) {
return @{
Message = 'Invalid client certificate supplied'
Code = 401
}
}
# ensure the cert hasn't expired, or has it even started
$now = [datetime]::Now
if (($cert.NotAfter -lt $now) -or ($cert.NotBefore -gt $now)) {
return @{
Message = 'Invalid client certificate supplied'
Code = 401
}
}
# return data for calling validator
return @($cert, $WebEvent.Request.ClientCertificateErrors)
}
}
function Get-PodeAuthBearerType
{
return {
param($options)
# get the auth header
$header = (Get-PodeHeader -Name 'Authorization')
if ($null -eq $header) {
return @{
Message = 'No Authorization header found'
Challenge = (New-PodeAuthBearerChallenge -Scopes $options.Scopes -ErrorType invalid_request)
Code = 400
}
}
# ensure the first atom is bearer
$atoms = $header -isplit '\s+'
if ($atoms.Length -lt 2) {
return @{
Message = 'Invalid Authorization header'
Challenge = (New-PodeAuthBearerChallenge -Scopes $options.Scopes -ErrorType invalid_request)
Code = 400
}
}
if ($atoms[0] -ine 'Bearer') {
return @{
Message = 'Authorization header is not Bearer'
Challenge = (New-PodeAuthBearerChallenge -Scopes $options.Scopes -ErrorType invalid_request)
Code = 400
}
}
# return token for calling validator
return @($atoms[1].Trim())
}
}
function Get-PodeAuthBearerPostValidator
{
return {
param($token, $result, $options)
# if there's no user, fail with challenge
if (($null -eq $result) -or ($null -eq $result.User)) {
return @{
Message = 'User not found'
Challenge = (New-PodeAuthBearerChallenge -Scopes $options.Scopes -ErrorType invalid_token)
Code = 401
}
}
# check for an error and description
if (![string]::IsNullOrWhiteSpace($result.Error)) {
return @{
Message = 'Authorization failed'
Challenge = (New-PodeAuthBearerChallenge -Scopes $options.Scopes -ErrorType $result.Error -ErrorDescription $result.ErrorDescription)
Code = 401
}
}
# check the scopes
$hasAuthScopes = (($null -ne $options.Scopes) -and ($options.Scopes.Length -gt 0))
$hasTokenScope = ![string]::IsNullOrWhiteSpace($result.Scope)
# 403 if we have auth scopes but no token scope
if ($hasAuthScopes -and !$hasTokenScope) {
return @{
Message = 'Invalid Scope'
Challenge = (New-PodeAuthBearerChallenge -Scopes $options.Scopes -ErrorType insufficient_scope)
Code = 403
}
}
# 403 if we have both, but token not in auth scope
if ($hasAuthScopes -and $hasTokenScope -and ($options.Scopes -notcontains $result.Scope)) {
return @{
Message = 'Invalid Scope'
Challenge = (New-PodeAuthBearerChallenge -Scopes $options.Scopes -ErrorType insufficient_scope)
Code = 403
}
}
# return result
return $result
}
}
function New-PodeAuthBearerChallenge
{
param(
[Parameter()]
[string[]]
$Scopes,
[Parameter()]
[ValidateSet('', 'invalid_request', 'invalid_token', 'insufficient_scope')]
[string]
$ErrorType,
[Parameter()]
[string]
$ErrorDescription
)
$items = @()
if (($null -ne $Scopes) -and ($Scopes.Length -gt 0)) {
$items += "scope=`"$($Scopes -join ' ')`""
}
if (![string]::IsNullOrWhiteSpace($ErrorType)) {
$items += "error=`"$($ErrorType)`""
}
if (![string]::IsNullOrWhiteSpace($ErrorDescription)) {
$items += "error_description=`"$($ErrorDescription)`""
}
return ($items -join ', ')
}
function Get-PodeAuthDigestType
{
return {
param($options)
# get the auth header - send challenge if missing
$header = (Get-PodeHeader -Name 'Authorization')
if ($null -eq $header) {
return @{
Message = 'No Authorization header found'
Challenge = (New-PodeAuthDigestChallenge)
Code = 401
}
}
# if auth header isn't digest send challenge
$atoms = $header -isplit '\s+'
if ($atoms.Length -lt 2) {
return @{
Message = 'Invalid Authorization header'
Code = 400
}
}
if ($atoms[0] -ine 'Digest') {
return @{
Message = 'Authorization header is not Digest'
Challenge = (New-PodeAuthDigestChallenge)
Code = 401
}
}
# parse the other atoms of the header (after the scheme), return 400 if none
$params = ConvertFrom-PodeAuthDigestHeader -Parts ($atoms[1..$($atoms.Length - 1)])
if ($params.Count -eq 0) {
return @{
Message = 'Invalid Authorization header'
Code = 400
}
}
# if no username then 401 and challenge
if ([string]::IsNullOrWhiteSpace($params.username)) {
return @{
Message = 'Authorization header is missing username'
Challenge = (New-PodeAuthDigestChallenge)
Code = 401
}
}
# return 400 if domain doesnt match request domain
if ($WebEvent.Path -ine $params.uri) {
return @{
Message = 'Invalid Authorization header'
Code = 400
}
}
# return data for calling validator
return @($params.username, $params)
}
}
function Get-PodeAuthDigestPostValidator
{
return {
param($username, $params, $result, $options)
# if there's no user or password, fail with challenge
if (($null -eq $result) -or ($null -eq $result.User) -or [string]::IsNullOrWhiteSpace($result.Password)) {
return @{
Message = 'User not found'
Challenge = (New-PodeAuthDigestChallenge)
Code = 401
}
}
# generate the first hash
$hash1 = Invoke-PodeMD5Hash -Value "$($params.username):$($params.realm):$($result.Password)"
# generate the second hash
$hash2 = Invoke-PodeMD5Hash -Value "$($WebEvent.Method.ToUpperInvariant()):$($params.uri)"
# generate final hash
$final = Invoke-PodeMD5Hash -Value "$($hash1):$($params.nonce):$($params.nc):$($params.cnonce):$($params.qop):$($hash2)"
# compare final hash to client response
if ($final -ne $params.response) {
return @{
Message = 'Hashes failed to match'
Challenge = (New-PodeAuthDigestChallenge)
Code = 401
}
}
# hashes are valid, remove password and return result
$result.Remove('Password') | Out-Null
return $result
}
}
function ConvertFrom-PodeAuthDigestHeader
{
param(
[Parameter()]
[string[]]
$Parts
)
if (($null -eq $Parts) -or ($Parts.Length -eq 0)) {
return @{}
}
$obj = @{}
$value = ($Parts -join ' ')
@($value -isplit ',(?=(?:[^"]|"[^"]*")*$)') | ForEach-Object {
if ($_ -imatch '(?<name>\w+)=["]?(?<value>[^"]+)["]?$') {
$obj[$Matches['name']] = $Matches['value']
}
}
return $obj
}
function New-PodeAuthDigestChallenge
{
$items = @('qop="auth"', 'algorithm="MD5"', "nonce=`"$(New-PodeGuid -Secure -NoDashes)`"")
return ($items -join ', ')
}
function Get-PodeAuthFormType
{
return {
param($options)
# get user/pass keys to get from payload
$userField = $options.Fields.Username
$passField = $options.Fields.Password
# get the user/pass
$username = $WebEvent.Data.$userField
$password = $WebEvent.Data.$passField
# if either are empty, fail auth
if ([string]::IsNullOrWhiteSpace($username) -or [string]::IsNullOrWhiteSpace($password)) {
return @{
Message = 'Username or Password not supplied'
Code = 401
}
}
# return data for calling validator
return @($username, $password)
}
}
function Get-PodeAuthUserFileMethod
{
return {
param($username, $password, $options)
# load the file
$users = (Get-Content -Path $options.FilePath -Raw | ConvertFrom-Json)
# find the user by username - only use the first one
$user = @(foreach ($_user in $users) {
if ($_user.Username -ieq $username) {
$_user
break
}
})[0]
# fail if no user
if ($null -eq $user) {
return @{ Message = 'You are not authorised to access this website' }
}
# check the user's password
if (![string]::IsNullOrWhiteSpace($options.HmacSecret)) {
$hash = Invoke-PodeHMACSHA256Hash -Value $password -Secret $options.HmacSecret
}
else {
$hash = Invoke-PodeSHA256Hash -Value $password
}
if ($user.Password -ne $hash) {
return @{ Message = 'You are not authorised to access this website' }
}
# convert the user to a hashtable
$user = @{
Name = $user.Name
Username = $user.Username
Email = $user.Email
Groups = $user.Groups
Metadata = $user.Metadata
}
# is the user valid for any users/groups?
if (!(Test-PodeAuthUserGroups -User $user -Users $options.Users -Groups $options.Groups)) {
return @{ Message = 'You are not authorised to access this website' }
}
$result = @{ User = $user }
# call additional scriptblock if supplied
if ($null -ne $options.ScriptBlock.Script) {
$result = Invoke-PodeAuthInbuiltScriptBlock -User $result.User -ScriptBlock $options.ScriptBlock.Script -UsingVariables $options.ScriptBlock.UsingVariables
}
# return final result, this could contain a user obj, or an error message from custom scriptblock
return $result
}
}
function Get-PodeAuthWindowsADMethod
{
return {
param($username, $password, $options)
# parse username to remove domains
$username = (($username -split '@')[0] -split '\\')[-1]
# validate and retrieve the AD user
$noGroups = $options.NoGroups
$openLdap = $options.OpenLDAP
$result = Get-PodeAuthADResult `
-Server $options.Server `
-Domain $options.Domain `
-Username $username `
-Password $password `
-NoGroups:$noGroups `
-OpenLDAP:$openLdap
# if there's a message, fail and return the message
if (![string]::IsNullOrWhiteSpace($result.Message)) {
return $result
}
# if there's no user, then, err, oops
if (Test-PodeIsEmpty $result.User) {
return @{ Message = 'An unexpected error occured' }
}
# is the user valid for any users/groups - if not, error!
if (!(Test-PodeAuthUserGroups -User $result.User -Users $options.Users -Groups $options.Groups)) {
return @{ Message = 'You are not authorised to access this website' }
}
# call additional scriptblock if supplied
if ($null -ne $options.ScriptBlock.Script) {
$result = Invoke-PodeAuthInbuiltScriptBlock -User $result.User -ScriptBlock $options.ScriptBlock.Script -UsingVariables $options.ScriptBlock.UsingVariables
}
# return final result, this could contain a user obj, or an error message from custom scriptblock
return $result
}
}
function Invoke-PodeAuthInbuiltScriptBlock
{
param(
[Parameter(Mandatory=$true)]
[hashtable]
$User,
[Parameter(Mandatory=$true)]
[scriptblock]
$ScriptBlock,
[Parameter()]
$UsingVariables
)
$_tmp_args = @($User)
if ($null -ne $UsingVariables) {
$_vars = @()
foreach ($_var in $UsingVariables) {
$_vars += ,$_var.Value
}
$_tmp_args = $_vars + $_tmp_args
}
return (Invoke-PodeScriptBlock -ScriptBlock $ScriptBlock -Arguments $_tmp_args -Return -Splat)
}
function Get-PodeAuthWindowsLocalMethod
{
return {
param($username, $password, $options)
$user = @{
UserType = 'Local'
AuthenticationType = 'WinNT'
Username = $username
Name = [string]::Empty
Fqdn = $PodeContext.Server.ComputerName
Domain = 'localhost'
Groups = @()
}
Add-Type -AssemblyName System.DirectoryServices.AccountManagement -ErrorAction Stop
$context = [System.DirectoryServices.AccountManagement.PrincipalContext]::new('Machine', $PodeContext.Server.ComputerName)
$valid = $context.ValidateCredentials($username, $password)
if (!$valid) {
return @{ Message = 'Invalid credentials supplied' }
}
try {
$tmpUsername = $username -replace '\\', '/'
if ($username -inotlike "$($PodeContext.Server.ComputerName)*") {
$tmpUsername = "$($PodeContext.Server.ComputerName)/$($username)"
}
$ad = [adsi]"WinNT://$($tmpUsername)"
$user.Name = @($ad.FullName)[0]
if (!$options.NoGroups) {
$cmd = "`$ad = [adsi]'WinNT://$($tmpUsername)'; @(`$ad.Groups() | Foreach-Object { `$_.GetType().InvokeMember('Name', 'GetProperty', `$null, `$_, `$null) })"
$user.Groups = [string[]](powershell -c $cmd)
}
}
finally {
Close-PodeDisposable -Disposable $ad -Close
}
# is the user valid for any users/groups - if not, error!
if (!(Test-PodeAuthUserGroups -User $user -Users $options.Users -Groups $options.Groups)) {
return @{ Message = 'You are not authorised to access this website' }
}
$result = @{ User = $user }
# call additional scriptblock if supplied
if ($null -ne $options.ScriptBlock.Script) {
$result = Invoke-PodeAuthInbuiltScriptBlock -User $result.User -ScriptBlock $options.ScriptBlock.Script -UsingVariables $options.ScriptBlock.UsingVariables
}
# return final result, this could contain a user obj, or an error message from custom scriptblock
return $result
}
}
function Get-PodeAuthWindowsADIISMethod
{
return {
param($token, $options)
# get the close handler
$win32Handler = Add-Type -Name Win32CloseHandle -PassThru -MemberDefinition @'
[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool CloseHandle(IntPtr handle);
'@
try {
# parse the auth token and get the user
$winAuthToken = [System.IntPtr][Int]"0x$($token)"
$winIdentity = New-Object System.Security.Principal.WindowsIdentity($winAuthToken, 'Windows')
# get user and domain
$username = ($winIdentity.Name -split '\\')[-1]
$domain = ($winIdentity.Name -split '\\')[0]
# create base user object
$user = @{
UserType = 'Domain'
Identity = $winIdentity
AuthenticationType = $winIdentity.AuthenticationType
DistinguishedName = [string]::Empty
Username = $username
Name = [string]::Empty
Email = [string]::Empty
Fqdn = [string]::Empty
Domain = $domain
Groups = @()
}
# if the domain isn't local, attempt AD user
if (![string]::IsNullOrWhiteSpace($domain) -and (@('.', $PodeContext.Server.ComputerName) -inotcontains $domain)) {
# get the server's fdqn (and name/email)
try {
# Open ADSISearcher and change context to given domain
$searcher = [adsisearcher]""
$searcher.SearchRoot = [adsi]"LDAP://$($domain)"
$searcher.Filter = "ObjectSid=$($winIdentity.User.Value.ToString())"
# Query the ADSISearcher for the above defined SID
$ad = $searcher.FindOne()
# Save it to our existing array for later usage
$user.DistinguishedName = @($ad.Properties.distinguishedname)[0]
$user.Name = @($ad.Properties.name)[0]
$user.Email = @($ad.Properties.mail)[0]
$user.Fqdn = (Get-PodeADServerFromDistinguishedName -DistinguishedName $user.DistinguishedName)
}
finally {
Close-PodeDisposable -Disposable $searcher
}
try {
if (!$options.NoGroups) {
# open a new connection
$result = (Open-PodeAuthADConnection -Server $user.Fqdn -Domain $domain)
if (!$result.Success) {
return @{ Message = "Failed to connect to Domain Server '$($user.Fqdn)' of $domain for $($user.DistinguishedName)." }
}
# get the connection
$connection = $result.Connection
# get the users groups
$user.Groups = (Get-PodeAuthADGroups -Connection $connection -DistinguishedName $user.DistinguishedName)
}
}
finally {
if ($null -ne $connection) {
Close-PodeDisposable -Disposable $connection.Searcher
Close-PodeDisposable -Disposable $connection.Entry -Close
}
}
}
# otherwise, get details of local user
else {
# get the user's name and groups
try {
$user.UserType = 'Local'
if (!$options.NoLocalCheck) {
$localUser = $winIdentity.Name -replace '\\', '/'
$ad = [adsi]"WinNT://$($localUser)"
$user.Name = @($ad.FullName)[0]
# dirty, i know :/ - since IIS runs using pwsh, the InvokeMember part fails
# we can safely call windows powershell here, as IIS is only on windows.
if (!$options.NoGroups) {
$cmd = "`$ad = [adsi]'WinNT://$($localUser)'; @(`$ad.Groups() | Foreach-Object { `$_.GetType().InvokeMember('Name', 'GetProperty', `$null, `$_, `$null) })"
$user.Groups = [string[]](powershell -c $cmd)
}
}
}
finally {
Close-PodeDisposable -Disposable $ad -Close
}
}
}
catch {
$_ | Write-PodeErrorLog
return @{ Message = 'Failed to retrieve user using Authentication Token' }
}
finally {
$win32Handler::CloseHandle($winAuthToken)
}
# is the user valid for any users/groups - if not, error!
if (!(Test-PodeAuthUserGroups -User $user -Users $options.Users -Groups $options.Groups)) {
return @{ Message = 'You are not authorised to access this website' }
}
$result = @{ User = $user }
# call additional scriptblock if supplied
if ($null -ne $options.ScriptBlock.Script) {
$result = Invoke-PodeAuthInbuiltScriptBlock -User $result.User -ScriptBlock $options.ScriptBlock.Script -UsingVariables $options.ScriptBlock.UsingVariables
}
# return final result, this could contain a user obj, or an error message from custom scriptblock
return $result
}
}
function Test-PodeAuthUserGroups
{
param(
[Parameter(Mandatory=$true)]
[hashtable]
$User,
[Parameter()]
[string[]]
$Users,
[Parameter()]
[string[]]
$Groups
)
$haveUsers = (($null -ne $Users) -and ($Users.Length -gt 0))
$haveGroups = (($null -ne $Groups) -and ($Groups.Length -gt 0))
# if there are no groups/users supplied, return user is valid
if (!$haveUsers -and !$haveGroups) {
return $true
}
# before checking supplied groups, is the user in the supplied list of authorised users?
if ($haveUsers -and (@($Users) -icontains $User.Username)) {
return $true
}
# if there are groups supplied, check the user is a member of one
if ($haveGroups) {
foreach ($group in $Groups) {
if (@($User.Groups) -icontains $group) {
return $true
}
}
}
return $false
}
function Get-PodeAuthMiddlewareScript
{
return {
param($opts)
# get the auth method
$auth = Find-PodeAuth -Name $opts.Name
# route options for using sessions
$sessionless = $auth.Sessionless
$usingSessions = (!(Test-PodeIsEmpty $WebEvent.Session))
$useHeaders = [bool]($WebEvent.Session.Properties.UseHeaders)
$loginRoute = $opts.Login
# check for logout command
if ($opts.Logout) {
Remove-PodeAuthSession
if ($useHeaders) {
return (Set-PodeAuthStatus -StatusCode 401 -Sessionless:$sessionless -NoSuccessRedirect)
}
else {
$auth.Failure.Url = (Protect-PodeValue -Value $auth.Failure.Url -Default $WebEvent.Request.Url.AbsolutePath)
return (Set-PodeAuthStatus -StatusCode 302 -Failure $auth.Failure -Sessionless:$sessionless -NoSuccessRedirect)
}
}
# if the session already has a user/isAuth'd, then skip auth
if ($usingSessions -and !(Test-PodeIsEmpty $WebEvent.Session.Data.Auth.User) -and $WebEvent.Session.Data.Auth.IsAuthenticated) {
$WebEvent.Auth = $WebEvent.Session.Data.Auth
return (Set-PodeAuthStatus -Success $auth.Success -LoginRoute:$loginRoute -Sessionless:$sessionless -NoSuccessRedirect)
}
# check if the login flag is set, in which case just return and load a login get-page
if ($loginRoute -and !$useHeaders -and ($WebEvent.Method -ieq 'get')) {
if (!(Test-PodeIsEmpty $WebEvent.Session.Data.Auth)) {
Revoke-PodeSession -Session $WebEvent.Session
}
return $true
}
try {
$result = $null
# run auth scheme script to parse request for data
$_args = @($auth.Scheme.Arguments)
if ($null -ne $auth.Scheme.ScriptBlock.UsingVariables) {
$_vars = @()
foreach ($_var in $auth.Scheme.ScriptBlock.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
# call inner schemes first
if ($null -ne $auth.Scheme.InnerScheme) {
$schemes = @()
$_scheme = $auth.Scheme
$_inner = @(while ($null -ne $_scheme.InnerScheme) {
$_scheme = $_scheme.InnerScheme
$_scheme
})
for ($i = $_inner.Length - 1; $i -ge 0; $i--) {
$_tmp_args = @($_inner[$i].Arguments)
if ($null -ne $_inner[$i].ScriptBlock.UsingVariables) {
$_vars = @()
foreach ($_var in $_inner[$i].ScriptBlock.UsingVariables) {
$_vars += ,$_var.Value
}
$_tmp_args = $_vars + $_tmp_args
}
$_tmp_args += ,$schemes
$result = (Invoke-PodeScriptBlock -ScriptBlock $_inner[$i].ScriptBlock.Script -Arguments $_tmp_args -Return -Splat)
if ($result -is [hashtable]) {
break
}
$schemes += ,$result
$result = $null
}
$_args += ,$schemes
}
if ($null -eq $result) {
$result = (Invoke-PodeScriptBlock -ScriptBlock $auth.Scheme.ScriptBlock.Script -Arguments $_args -Return -Splat)
}
# if data is a hashtable, then don't call validator (parser either failed, or forced a success)
if ($result -isnot [hashtable]) {
$original = $result
$_args = @($result) + @($auth.Arguments)
if ($null -ne $auth.UsingVariables) {
$_vars = @()
foreach ($_var in $auth.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
$result = (Invoke-PodeScriptBlock -ScriptBlock $auth.ScriptBlock -Arguments $_args -Return -Splat)
# if we have user, then run post validator if present
if ([string]::IsNullOrWhiteSpace($result.Code) -and !(Test-PodeIsEmpty $auth.Scheme.PostValidator.Script)) {
$_args = @($original) + @($result) + @($auth.Scheme.Arguments)
if ($null -ne $auth.Scheme.PostValidator.UsingVariables) {
$_vars = @()
foreach ($_var in $auth.Scheme.PostValidator.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
$result = (Invoke-PodeScriptBlock -ScriptBlock $auth.Scheme.PostValidator.Script -Arguments $_args -Return -Splat)
}
}
}
catch {
$_ | Write-PodeErrorLog
return (Set-PodeAuthStatus -StatusCode 500 -Description $_.Exception.Message -Failure $auth.Failure -Sessionless:$sessionless)
}
# did the auth force a redirect?
if ($result.IsRedirected) {
return $false
}
# if there is no result, return false (failed auth)
if ((Test-PodeIsEmpty $result) -or (Test-PodeIsEmpty $result.User)) {
$_code = (Protect-PodeValue -Value $result.Code -Default 401)
# set the www-auth header
$validCode = (($_code -eq 401) -or ![string]::IsNullOrWhiteSpace($result.Challenge))
$validHeaders = (($null -eq $result.Headers) -or !$result.Headers.ContainsKey('WWW-Authenticate'))
if ($validCode -and $validHeaders) {
$_wwwHeader = Get-PodeAuthWwwHeaderValue -Name $auth.Scheme.Name -Realm $auth.Scheme.Realm -Challenge $result.Challenge
if (![string]::IsNullOrWhiteSpace($_wwwHeader)) {
Set-PodeHeader -Name 'WWW-Authenticate' -Value $_wwwHeader
}
}
return (Set-PodeAuthStatus `
-StatusCode $_code `
-Description $result.Message `
-Headers $result.Headers `
-Failure $auth.Failure `
-Success $auth.Success `
-LoginRoute:$loginRoute `
-Sessionless:$sessionless)
}
# assign the user to the session, and wire up a quick method
$WebEvent.Auth = @{}
$WebEvent.Auth.User = $result.User
$WebEvent.Auth.IsAuthenticated = $true
$WebEvent.Auth.Store = !$sessionless
# continue
return (Set-PodeAuthStatus -Headers $result.Headers -Success $auth.Success -LoginRoute:$loginRoute -Sessionless:$sessionless)
}
}
function Get-PodeAuthWwwHeaderValue
{
param(
[Parameter()]
[string]
$Name,
[Parameter()]
[string]
$Realm,
[Parameter()]
[string]
$Challenge
)
if ([string]::IsNullOrWhiteSpace($Name)) {
return [string]::Empty
}
$header = $Name
if (![string]::IsNullOrWhiteSpace($Realm)) {
$header += " realm=`"$($Realm)`""
}
if (![string]::IsNullOrWhiteSpace($Challenge)) {
$header += ", $($Challenge)"
}
return $header
}
function Remove-PodeAuthSession
{
# blank out the auth
$WebEvent.Auth = @{}
# if a session auth is found, blank it
if (!(Test-PodeIsEmpty $WebEvent.Session.Data.Auth)) {
$WebEvent.Session.Data.Remove('Auth')
}
# Delete the session (remove from store, blank it, and remove from Response)
Revoke-PodeSession -Session $WebEvent.Session
}
function Set-PodeAuthStatus
{
param (
[Parameter()]
[int]
$StatusCode = 0,
[Parameter()]
[string]
$Description,
[Parameter()]
[hashtable]
$Headers,
[Parameter()]
[hashtable]
$Failure,
[Parameter()]
[hashtable]
$Success,
[switch]
$LoginRoute,
[switch]
$Sessionless,
[switch]
$NoSuccessRedirect
)
# if we have any headers, set them
if (($null -ne $Headers) -and ($Headers.Count -gt 0)) {
foreach ($name in $Headers.Keys) {
Set-PodeHeader -Name $name -Value $Headers[$name]
}
}
# if a statuscode supplied, assume failure
if ($StatusCode -gt 0)
{
# override description with the failureMessage if supplied
$Description = (Protect-PodeValue -Value $Failure.Message -Default $Description)
# add error to flash
if ($LoginRoute -and !$Sessionless -and ![string]::IsNullOrWhiteSpace($Description)) {
Add-PodeFlashMessage -Name 'auth-error' -Message $Description
}
# check if we have a failure url redirect
if (![string]::IsNullOrWhiteSpace($Failure.Url)) {
Move-PodeResponseUrl -Url $Failure.Url
}
else {
Set-PodeResponseStatus -Code $StatusCode -Description $Description
}
return $false
}
# if no statuscode, success, so check if we have a success url redirect (but only for auto-login routes)
if ((!$NoSuccessRedirect -or $LoginRoute) -and ![string]::IsNullOrWhiteSpace($Success.Url)) {
Move-PodeResponseUrl -Url $Success.Url
return $false
}
return $true
}
function Get-PodeADServerFromDistinguishedName
{
param(
[Parameter()]
[string]
$DistinguishedName
)
if ([string]::IsNullOrWhiteSpace($DistinguishedName)) {
return [string]::Empty
}
$parts = @($DistinguishedName -split ',')
$name = @()
foreach ($part in $parts) {
if ($part -imatch '^DC=(?<name>.+)$') {
$name += $Matches['name']
}
}
return ($name -join '.')
}
function Get-PodeAuthADResult
{
param (
[Parameter()]
[string]
$Server,
[Parameter()]
[string]
$Domain,
[Parameter()]
[string]
$Username,
[Parameter()]
[string]
$Password,
[switch]
$NoGroups,
[switch]
$OpenLDAP
)
try
{
# validate the user's AD creds
$result = (Open-PodeAuthADConnection -Server $Server -Domain $Domain -Username $Username -Password $Password -OpenLDAP:$OpenLDAP)
if (!$result.Success) {
return @{ Message = 'Invalid credentials supplied' }
}
# get the connection
$connection = $result.Connection
# get the user
$user = (Get-PodeAuthADUser -Connection $connection -Username $Username -OpenLDAP:$OpenLDAP)
if ($null -eq $user) {
return @{ Message = 'User not found in Active Directory' }
}
# get the users groups
$groups = @()
if (!$NoGroups) {
$groups = (Get-PodeAuthADGroups -Connection $connection -DistinguishedName $user.DistinguishedName -OpenLDAP:$OpenLDAP)
}
# return the user
return @{
User = @{
UserType = 'Domain'
AuthenticationType = 'LDAP'
DistinguishedName = $user.DistinguishedName
Username = ($Username -split '\\')[-1]
Name = $user.Name
Email = $user.Email
Fqdn = $Server
Domain = $Domain
Groups = $groups
}
}
}
finally {
if ((Test-PodeIsWindows) -and !$OpenLDAP -and ($null -ne $connection)) {
Close-PodeDisposable -Disposable $connection.Searcher
Close-PodeDisposable -Disposable $connection.Entry -Close
}
}
}
function Open-PodeAuthADConnection
{
param (
[Parameter(Mandatory=$true)]
[string]
$Server,
[Parameter()]
[string]
$Domain,
[Parameter()]
[string]
$Username,
[Parameter()]
[string]
$Password,
[Parameter()]
[ValidateSet('LDAP', 'WinNT')]
[string]
$Protocol = 'LDAP',
[switch]
$OpenLDAP
)
$result = $true
$connection = $null
# validate the user's AD creds
if ((Test-PodeIsWindows) -and !$OpenLDAP) {
if ([string]::IsNullOrWhiteSpace($Password)) {
$ad = (New-Object System.DirectoryServices.DirectoryEntry "$($Protocol)://$($Server)")
}
else {
$ad = (New-Object System.DirectoryServices.DirectoryEntry "$($Protocol)://$($Server)", "$($Username)", "$($Password)")
}
if (Test-PodeIsEmpty $ad.distinguishedName) {
$result = $false
}
else {
$connection = @{
Entry = $ad
}
}
}
else {
$dcName = "DC=$(($Server -split '\.') -join ',DC=')"
$query = (Get-PodeAuthADQuery -Username $Username)
$hostname = "$($Protocol)://$($Server)"
$user = $Username
if (!$Username.StartsWith($Domain)) {
$user = "$($Domain)\$($Username)"
}
(ldapsearch -x -LLL -H "$($hostname)" -D "$($user)" -w "$($Password)" -b "$($dcName)" "$($query)" dn) | Out-Null
if (!$? -or ($LASTEXITCODE -ne 0)) {
$result = $false
}
else {
$connection = @{
Hostname = $hostname
Username = $user
DCName = $dcName
Password = $Password
}
}
}
return @{
Success = $result
Connection = $connection
}
}
function Get-PodeAuthADQuery
{
param(
[Parameter(Mandatory=$true)]
[string]
$Username
)
return "(&(objectCategory=person)(samaccountname=$($Username)))"
}
function Get-PodeAuthADUser
{
param(
[Parameter(Mandatory=$true)]
$Connection,
[Parameter(Mandatory=$true)]
[string]
$Username,
[switch]
$OpenLDAP
)
$query = (Get-PodeAuthADQuery -Username $Username)
# generate query to find user
if ((Test-PodeIsWindows) -and !$OpenLDAP) {
$Connection.Searcher = New-Object System.DirectoryServices.DirectorySearcher $Connection.Entry
$Connection.Searcher.filter = $query
$result = $Connection.Searcher.FindOne().Properties
if (Test-PodeIsEmpty $result) {
return $null
}
$user = @{
DistinguishedName = @($result.distinguishedname)[0]
Name = @($result.name)[0]
Email = @($result.mail)[0]
}
}
else {
$result = (ldapsearch -x -LLL -H "$($Connection.Hostname)" -D "$($Connection.Username)" -w "$($Connection.Password)" -b "$($Connection.DCName)" "$($query)" name mail)
if (!$? -or ($LASTEXITCODE -ne 0)) {
return $null
}
$user = @{
DistinguishedName = (Get-PodeOpenLdapValue -Lines $result -Property 'dn')
Name = (Get-PodeOpenLdapValue -Lines $result -Property 'name')
Email = (Get-PodeOpenLdapValue -Lines $result -Property 'mail')
}
}
return $user
}
function Get-PodeOpenLdapValue
{
param(
[Parameter()]
[string[]]
$Lines,
[Parameter()]
[string]
$Property,
[switch]
$All
)
foreach ($line in $Lines) {
if ($line -imatch "^$($Property)\:\s+(?<$($Property)>.+)$") {
# return the first found
if (!$All) {
return $Matches[$Property]
}
# return array of all
$Matches[$Property]
}
}
}
function Get-PodeAuthADGroups
{
param (
[Parameter(Mandatory=$true)]
$Connection,
[Parameter()]
[string]
$DistinguishedName,
[switch]
$OpenLDAP
)
# create the query
$query = "(member:1.2.840.113556.1.4.1941:=$($DistinguishedName))"
$groups = @()
# get the groups
if ((Test-PodeIsWindows) -and !$OpenLDAP) {
if ($null -eq $Connection.Searcher) {
$Connection.Searcher = New-Object System.DirectoryServices.DirectorySearcher $Connection.Entry
}
$Connection.Searcher.PropertiesToLoad.Add('samaccountname') | Out-Null
$Connection.Searcher.filter = $query
$groups = @($Connection.Searcher.FindAll().Properties.samaccountname)
}
else {
$result = (ldapsearch -x -LLL -H "$($Connection.Hostname)" -D "$($Connection.Username)" -w "$($Connection.Password)" -b "$($Connection.DCName)" "$($query)" samaccountname)
$groups = (Get-PodeOpenLdapValue -Lines $result -Property 'sAMAccountName' -All)
}
return $groups
}
function Get-PodeAuthDomainName
{
if (Test-PodeIsUnix) {
$dn = (dnsdomainname)
if ([string]::IsNullOrWhiteSpace($dn)) {
$dn = (/usr/sbin/realm list --name-only)
}
return $dn
}
else {
$domain = $env:USERDNSDOMAIN
if ([string]::IsNullOrWhiteSpace($domain)) {
$domain = (Get-CimInstance -Class Win32_ComputerSystem -Verbose:$false).Domain
}
return $domain
}
}
function Find-PodeAuth
{
param(
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Name
)
return $PodeContext.Server.Authentications[$Name]
}
function Test-PodeAuth
{
param(
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Name
)
return $PodeContext.Server.Authentications.ContainsKey($Name)
}
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]
$ServerlessType,
[Parameter()]
[string]
$StatusPageExceptions,
[Parameter()]
[string]
$ListenerType,
[switch]
$DisableTermination,
[switch]
$Quiet
)
# set a random server name if one not supplied
if (Test-PodeIsEmpty $Name) {
$Name = Get-PodeRandomName
}
# are we running in a serverless context
$isServerless = ![string]::IsNullOrWhiteSpace($ServerlessType)
# 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 |
Add-Member -MemberType NoteProperty -Name Listeners -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
$ctx.Server.ComputerName = [System.Net.DNS]::GetHostName()
# list of created listeners
$ctx.Listeners = @()
# auto importing (modules, funcs, snap-ins)
$ctx.Server.AutoImport = @{
Modules = @{
Enabled = $true
ExportList = @()
ExportOnly = $false
}
Snapins = @{
Enabled = $true
ExportList = @()
ExportOnly = $false
}
Functions = @{
Enabled = $true
ExportList = @()
ExportOnly = $false
}
}
# basic logging setup
$ctx.Server.Logging = @{
Enabled = $true
Types = @{}
}
# set thread counts
$ctx.Threads = @{
General = $Threads
Schedules = 10
}
# set socket details for pode server
$ctx.Server.Sockets = @{
Ssl = @{
Protocols = (ConvertTo-PodeSslProtocols -Protocols @('Ssl3', 'Tls12'))
}
ReceiveTimeout = 100
}
$ctx.Server.WebSockets = @{
Enabled = $false
Listener = $null
}
# check if there is any global configuration
$ctx.Server.Configuration = Open-PodeConfiguration -ServerRoot $ServerRoot -Context $ctx
# over status page exceptions
if (!(Test-PodeIsEmpty $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-PodeIsEmpty $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's listener type
$ctx.Server.ListenerType = $ListenerType
# set serverless info
$ctx.Server.ServerlessType = $ServerlessType
$ctx.Server.IsServerless = $isServerless
if ($isServerless) {
$ctx.Server.DisableTermination = $true
}
# set the server types
$ctx.Server.IsService = ($Interval -gt 0)
$ctx.Server.Types = @()
# is the server running under IIS? (also, disable termination)
$ctx.Server.IsIIS = (!$isServerless -and (!(Test-PodeIsEmpty $env:ASPNETCORE_PORT)) -and (!(Test-PodeIsEmpty $env:ASPNETCORE_TOKEN)))
if ($ctx.Server.IsIIS) {
$ctx.Server.DisableTermination = $true
# if under IIS and Azure Web App, force quiet
if (!(Test-PodeIsEmpty $env:WEBSITE_IIS_SITE_NAME)) {
$ctx.Server.Quiet = $true
}
}
# is the server running under Heroku?
$ctx.Server.IsHeroku = (!$isServerless -and (!(Test-PodeIsEmpty $env:PORT)) -and (!(Test-PodeIsEmpty $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 = @{}
$ctx.Server.EndpointsMap = @{}
$ctx.Server.FindRouteEndpoint = $false
# 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'
ScriptBlock = $null
UsingVariables = $null
IsDynamic = $false
}
# routes for pages and api
$ctx.Server.Routes = @{
'delete' = @{};
'get' = @{};
'head' = @{};
'merge' = @{};
'options' = @{};
'patch' = @{};
'post' = @{};
'put' = @{};
'trace' = @{};
'static' = @{};
'*' = @{};
}
# custom view paths
$ctx.Server.Views = @{}
# 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 = Get-PodeOABaseObject
# 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
Web = $null
Smtp = $null
Tcp = $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
{
# create the state, and add the pode module
$state = [initialsessionstate]::CreateDefault()
$state.ImportPSModule($PodeContext.Server.PodeModulePath)
# load the vars into the share state
$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 Import-PodeFunctionsIntoRunspaceState
{
param(
[Parameter(Mandatory=$true, ParameterSetName='Script')]
[scriptblock]
$ScriptBlock,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$FilePath
)
# do nothing if disabled
if (!$PodeContext.Server.AutoImport.Functions.Enabled) {
return
}
# if export only, and there are none, do nothing
if ($PodeContext.Server.AutoImport.Functions.ExportOnly -and ($PodeContext.Server.AutoImport.Functions.ExportList.Length -eq 0)) {
return
}
# script or file functions?
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'script' {
$funcs = (Get-PodeFunctionsFromScriptBlock -ScriptBlock $ScriptBlock)
}
'file' {
$funcs = (Get-PodeFunctionsFromFile -FilePath $FilePath)
}
}
# looks like we have nothing!
if (($null -eq $funcs) -or ($funcs.Length -eq 0)) {
return
}
# groups funcs in case there or multiple definitions
$funcs = ($funcs | Group-Object -Property { $_.Name })
# import them, but also check if they're exported
foreach ($func in $funcs) {
# only exported funcs? is the func exported?
if ($PodeContext.Server.AutoImport.Functions.ExportOnly -and ($PodeContext.Server.AutoImport.Functions.ExportList -inotcontains $func.Name)) {
continue
}
# load the function
$funcDef = [System.Management.Automation.Runspaces.SessionStateFunctionEntry]::new($func.Name, $func.Group[-1].Definition)
$PodeContext.RunspaceState.Commands.Add($funcDef)
}
}
function Import-PodeModulesIntoRunspaceState
{
# do nothing if disabled
if (!$PodeContext.Server.AutoImport.Modules.Enabled) {
return
}
# if export only, and there are none, do nothing
if ($PodeContext.Server.AutoImport.Modules.ExportOnly -and ($PodeContext.Server.AutoImport.Modules.ExportList.Length -eq 0)) {
return
}
# load modules into runspaces, if allowed
$modules = (Get-Module | Where-Object { ($_.ModuleType -ieq 'script') -and ($_.Name -ine 'pode') }).Name | Sort-Object -Unique
foreach ($module in $modules) {
# only exported modules? is the module exported?
if ($PodeContext.Server.AutoImport.Modules.ExportOnly -and ($PodeContext.Server.AutoImport.Modules.ExportList -inotcontains $module)) {
continue
}
$path = (Get-Module -Name $module | Sort-Object -Property Version -Descending | Select-Object -First 1 -ExpandProperty Path)
$PodeContext.RunspaceState.ImportPSModule($path)
}
}
function Import-PodeSnapinsIntoRunspaceState
{
# if non-windows or core, do nothing
if ((Test-PodeIsPSCore) -or (Test-PodeIsUnix)) {
return
}
# do nothing if disabled
if (!$PodeContext.Server.AutoImport.Snapins.Enabled) {
return
}
# if export only, and there are none, do nothing
if ($PodeContext.Server.AutoImport.Snapins.ExportOnly -and ($PodeContext.Server.AutoImport.Snapins.ExportList.Length -eq 0)) {
return
}
# load snapins into runspaces, if allowed
$snapins = (Get-PSSnapin | Where-Object { !$_.IsDefault }).Name | Sort-Object -Unique
foreach ($snapin in $snapins) {
# only exported snapins? is the snapin exported?
if ($PodeContext.Server.AutoImport.Snapins.ExportOnly -and ($PodeContext.Server.AutoImport.Snapins.ExportList -inotcontains $snapin)) {
continue
}
$PodeContext.RunspaceState.ImportPSSnapIn($snapin, [ref]$null)
}
}
function New-PodeRunspacePools
{
if ($PodeContext.Server.IsServerless) {
return
}
# setup main runspace pool
$threadsCounts = @{
Default = 3
Timer = 1
Log = 1
Schedule = 1
Misc = 1
}
# main runspace - for timers, schedules, etc
$totalThreadCount = ($threadsCounts.Values | Measure-Object -Sum).Sum
$PodeContext.RunspacePools.Main = [runspacefactory]::CreateRunspacePool(1, $totalThreadCount, $PodeContext.RunspaceState, $Host)
# web runspace - if we have any http/s endpoints
if (Test-PodeEndpoints -Type Http) {
$PodeContext.RunspacePools.Web = [runspacefactory]::CreateRunspacePool(1, ($PodeContext.Threads.General + 1), $PodeContext.RunspaceState, $Host)
}
# smtp runspace - if we have any smtp endpoints
if (Test-PodeEndpoints -Type Smtp) {
$PodeContext.RunspacePools.Smtp = [runspacefactory]::CreateRunspacePool(1, ($PodeContext.Threads.General + 1), $PodeContext.RunspaceState, $Host)
}
# tcp runspace - if we have any tcp endpoints
if (Test-PodeEndpoints -Type Tcp) {
$PodeContext.RunspacePools.Tcp = [runspacefactory]::CreateRunspacePool(1, ($PodeContext.Threads.General + 1), $PodeContext.RunspaceState, $Host)
}
# web socket runspace - if we have any ws/s endpoints
if (Test-PodeEndpoints -Type Ws) {
$PodeContext.RunspacePools.Signals = [runspacefactory]::CreateRunspacePool(1, 3, $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 (!$PodeContext.Server.IsServerless -and !((Test-PodeIsPSCore) -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-PodeIsEmpty $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 = (($null -eq $Configuration.Logging.Enable) -or [bool]$Configuration.Logging.Enable)
Masking = @{
Patterns = (Remove-PodeEmptyItemsFromArray -Array @($Configuration.Logging.Masking.Patterns))
Mask = (Protect-PodeValue -Value $Configuration.Logging.Masking.Mask -Default '********')
}
Types = @{}
}
# sockets
if (!(Test-PodeIsEmpty $Configuration.Ssl.Protocols)) {
$Context.Server.Sockets.Ssl.Protocols = (ConvertTo-PodeSslProtocols -Protocols $Configuration.Ssl.Protocols)
}
if ([int]$Configuration.ReceiveTimeout -gt 0) {
$Context.Server.Sockets.ReceiveTimeout = (Protect-PodeValue -Value $Configuration.ReceiveTimeout $Context.Server.Sockets.ReceiveTimeout)
}
# auto-import
$Context.Server.AutoImport = @{
Modules = @{
Enabled = (($null -eq $Configuration.AutoImport.Modules.Enable) -or [bool]$Configuration.AutoImport.Modules.Enable)
ExportList = @()
ExportOnly = ([bool]$Configuration.AutoImport.Modules.ExportOnly)
}
Snapins = @{
Enabled = (($null -eq $Configuration.AutoImport.Snapins.Enable) -or [bool]$Configuration.AutoImport.Snapins.Enable)
ExportList = @()
ExportOnly = ([bool]$Configuration.AutoImport.Snapins.ExportOnly)
}
Functions = @{
Enabled = (($null -eq $Configuration.AutoImport.Functions.Enable) -or [bool]$Configuration.AutoImport.Functions.Enable)
ExportList = @()
ExportOnly = ([bool]$Configuration.AutoImport.Functions.ExportOnly)
}
}
}
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-PodeCronFields
{
return @(
'Minute',
'Hour',
'DayOfMonth',
'Month',
'DayOfWeek'
)
}
function Get-PodeCronFieldConstraints
{
return @{
MinMax = @(
@(0, 59),
@(0, 23),
@(1, 31),
@(1, 12),
@(0, 6)
)
DaysInMonths = @(
31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
)
Months = @(
'January', 'February', 'March', 'April', 'May', 'June', 'July',
'August', 'September', 'October', 'November', 'December'
)
}
}
function Get-PodeCronPredefined
{
return @{
# normal
'@minutely' = '* * * * *';
'@hourly' = '0 * * * *';
'@daily' = '0 0 * * *';
'@weekly' = '0 0 * * 0';
'@monthly' = '0 0 1 * *';
'@quarterly' = '0 0 1 1,4,7,10 *';
'@yearly' = '0 0 1 1 *';
'@annually' = '0 0 1 1 *';
# twice
'@twice-hourly' = '0,30 * * * *';
'@twice-daily' = '0 0,12 * * *';
'@twice-weekly' = '0 0 * * 0,4';
'@twice-monthly' = '0 0 1,15 * *';
'@twice-yearly' = '0 0 1 1,6 *';
'@twice-annually' = '0 0 1 1,6 *';
}
}
function Get-PodeCronFieldAliases
{
return @{
Month = @{
Jan = 1
Feb = 2
Mar = 3
Apr = 4
May = 5
Jun = 6
Jul = 7
Aug = 8
Sep = 9
Oct = 10
Nov = 11
Dec = 12
}
DayOfWeek = @{
Sun = 0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
}
}
}
function ConvertFrom-PodeCronExpressions
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string[]]
$Expressions
)
return @(@($Expressions) | ForEach-Object {
ConvertFrom-PodeCronExpression -Expression $_
})
}
function ConvertFrom-PodeCronExpression
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Expression
)
$Expression = $Expression.Trim()
# check predefineds
$predef = Get-PodeCronPredefined
if (!(Test-PodeIsEmpty $predef[$Expression])) {
$Expression = $predef[$Expression]
}
# split and check atoms length
$atoms = @($Expression -isplit '\s+')
if ($atoms.Length -ne 5) {
throw "Cron expression should only consist of 5 parts: $($Expression)"
}
# basic variables
$aliasRgx = '(?<tag>[a-z]{3})'
# get cron obj and validate atoms
$fields = Get-PodeCronFields
$constraints = Get-PodeCronFieldConstraints
$aliases = Get-PodeCronFieldAliases
$cron = @{}
for ($i = 0; $i -lt $atoms.Length; $i++)
{
$_cronExp = @{
Range = $null
Values = $null
Constraints = $null
Random = $false
WildCard = $false
}
$_atom = $atoms[$i]
$_field = $fields[$i]
$_constraint = $constraints.MinMax[$i]
$_aliases = $aliases[$_field]
# replace day of week and months with numbers
if (@('month', 'dayofweek') -icontains $_field) {
while ($_atom -imatch $aliasRgx) {
$_alias = $_aliases[$Matches['tag']]
if ($null -eq $_alias) {
throw "Invalid $($_field) alias found: $($Matches['tag'])"
}
$_atom = $_atom -ireplace $Matches['tag'], $_alias
$_atom -imatch $aliasRgx | Out-Null
}
}
# ensure atom is a valid value
if (!($_atom -imatch '^[\d|/|*|\-|,r]+$')) {
throw "Invalid atom character: $($_atom)"
}
# replace * with min/max constraint
if ($_atom -ieq '*') {
$_cronExp.WildCard = $true
$_atom = ($_constraint -join '-')
}
# parse the atom for either a literal, range, array, or interval
# literal
if ($_atom -imatch '^(\d+|r)$') {
# check if it's random
if ($_atom -ieq 'r') {
$_cronExp.Values = @(Get-Random -Minimum $_constraint[0] -Maximum ($_constraint[1] + 1))
$_cronExp.Random = $true
}
else {
$_cronExp.Values = @([int]$_atom)
}
}
# range
elseif ($_atom -imatch '^(?<min>\d+)\-(?<max>\d+)$') {
$_cronExp.Range = @{ 'Min' = [int]($Matches['min'].Trim()); 'Max' = [int]($Matches['max'].Trim()); }
}
# array
elseif ($_atom -imatch '^[\d,]+$') {
$_cronExp.Values = [int[]](@($_atom -split ',').Trim())
}
# interval
elseif ($_atom -imatch '(?<start>(\d+|\*))\/(?<interval>(\d+|r))$') {
$start = $Matches['start']
$interval = $Matches['interval']
if ($interval -ieq '0') {
$interval = '1'
}
if ([string]::IsNullOrWhiteSpace($start) -or ($start -ieq '*')) {
$start = '0'
}
# set the initial trigger value
$_cronExp.Values = @([int]$start)
# check if it's random
if ($interval -ieq 'r') {
$_cronExp.Random = $true
}
else {
# loop to get all next values
$next = [int]$start + [int]$interval
while ($next -le $_constraint[1]) {
$_cronExp.Values += $next
$next += [int]$interval
}
}
}
# error
else {
throw "Invalid cron atom format found: $($_atom)"
}
# ensure cron expression values are valid
if ($null -ne $_cronExp.Range) {
if ($_cronExp.Range.Min -gt $_cronExp.Range.Max) {
throw "Min value for $($_field) should not be greater than the max value"
}
if ($_cronExp.Range.Min -lt $_constraint[0]) {
throw "Min value '$($_cronExp.Range.Min)' for $($_field) is invalid, should be greater than/equal to $($_constraint[0])"
}
if ($_cronExp.Range.Max -gt $_constraint[1]) {
throw "Max value '$($_cronExp.Range.Max)' for $($_field) is invalid, should be less than/equal to $($_constraint[1])"
}
}
if ($null -ne $_cronExp.Values) {
$_cronExp.Values | ForEach-Object {
if ($_ -lt $_constraint[0] -or $_ -gt $_constraint[1]) {
throw "Value '$($_)' for $($_field) is invalid, should be between $($_constraint[0]) and $($_constraint[1])"
}
}
}
# assign value
$_cronExp.Constraints = $_constraint
$cron[$_field] = $_cronExp
}
# post validation for month/days in month
if (($null -ne $cron['Month'].Values) -and ($null -ne $cron['DayOfMonth'].Values))
{
foreach ($mon in $cron['Month'].Values) {
foreach ($day in $cron['DayOfMonth'].Values) {
if ($day -gt $constraints.DaysInMonths[$mon - 1]) {
throw "$($constraints.Months[$mon - 1]) only has $($constraints.DaysInMonths[$mon - 1]) days, but $($day) was supplied"
}
}
}
}
# flag if this cron contains a random atom
$cron['Random'] = (($cron.Values | Where-Object { $_.Random } | Measure-Object).Count -gt 0)
# return the parsed cron expression
return $cron
}
function Reset-PodeRandomCronExpressions
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Expressions
)
return @(@($Expressions) | ForEach-Object {
Reset-PodeRandomCronExpression -Expression $_
})
}
function Reset-PodeRandomCronExpression
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Expression
)
function Reset-Atom($Atom) {
if (!$Atom.Random) {
return $Atom
}
if ($Atom.Random) {
$Atom.Values = @(Get-Random -Minimum $Atom.Constraints[0] -Maximum ($Atom.Constraints[1] + 1))
}
return $Atom
}
if (!$Expression.Random) {
return $Expression
}
$Expression.Minute = (Reset-Atom -Atom $Expression.Minute)
$Expression.Hour = (Reset-Atom -Atom $Expression.Hour)
$Expression.DayOfMonth = (Reset-Atom -Atom $Expression.DayOfMonth)
$Expression.Month = (Reset-Atom -Atom $Expression.Month)
$Expression.DayOfWeek = (Reset-Atom -Atom $Expression.DayOfWeek)
return $Expression
}
function Test-PodeCronExpressions
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Expressions,
[Parameter()]
$DateTime = $null
)
return ((@($Expressions) | Where-Object {
Test-PodeCronExpression -Expression $_ -DateTime $DateTime
} | Measure-Object).Count -gt 0)
}
function Test-PodeCronExpression
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Expression,
[Parameter()]
$DateTime = $null
)
function Test-RangeAndValue($AtomContraint, $NowValue) {
if ($null -ne $AtomContraint.Range) {
return (!(($NowValue -lt $AtomContraint.Range.Min) -or ($NowValue -gt $AtomContraint.Range.Max)))
}
return ($AtomContraint.Values -icontains $NowValue)
}
# current time
if ($null -eq $DateTime) {
$DateTime = [datetime]::Now
}
# check day of month
if (!(Test-RangeAndValue -AtomContraint $Expression.DayOfMonth -NowValue $DateTime.Day)) {
return $false
}
# check day of week
if (!(Test-RangeAndValue -AtomContraint $Expression.DayOfWeek -NowValue ([int]$DateTime.DayOfWeek))) {
return $false
}
# check month
if (!(Test-RangeAndValue -AtomContraint $Expression.Month -NowValue $DateTime.Month)) {
return $false
}
# check hour
if (!(Test-RangeAndValue -AtomContraint $Expression.Hour -NowValue $DateTime.Hour)) {
return $false
}
# check minute
if (!(Test-RangeAndValue -AtomContraint $Expression.Minute -NowValue $DateTime.Minute)) {
return $false
}
# date is valid
return $true
}
function Get-PodeCronNextEarliestTrigger
{
param(
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Expressions,
[Parameter()]
$StartTime = $null,
[Parameter()]
$EndTime = $null
)
return (@($Expressions) | Foreach-Object {
Get-PodeCronNextTrigger -Expression $_ -StartTime $StartTime -EndTime $EndTime
} | Where-Object { $null -ne $_ } | Sort-Object | Select-Object -First 1)
}
function Get-PodeCronNextTrigger
{
param(
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Expression,
[Parameter()]
$StartTime = $null,
[Parameter()]
$EndTime = $null
)
# start from the current time, if a start time not defined
if ($null -eq $StartTime) {
$StartTime = [datetime]::Now
}
$StartTime = $StartTime.AddMinutes(1)
# the next time to trigger
$NextTime = [datetime]::new($StartTime.Year, $StartTime.Month, $StartTime.Day, $StartTime.Hour, $StartTime.Minute, 0)
# first, is the current time valid?
if (Test-PodeCronExpression -Expression $Expression -DateTime $NextTime) {
return $NextTime
}
# functions for getting the closest value
function Get-ClosestValue($AtomContraint, $NowValue) {
$_values = $AtomContraint.Values
if ($null -eq $_values) {
$_values = ($AtomContraint.Range.Min..$AtomContraint.Range.Max)
}
if (($_values.Length -eq 1) -or ($_values[-1] -lt $NowValue) -or ($_values[0] -gt $NowValue)) {
return $_values[0]
}
return ($_values -ge $NowValue)[0]
}
# loop until we get a date
while ($true)
{
# check the minute
if (!$Expression.Minute.WildCard) {
$minute = Get-ClosestValue -AtomContraint $Expression.Minute -NowValue $NextTime.Minute
if ($minute -lt $NextTime.Minute) {
$NextTime = $NextTime.AddHours(1)
}
$NextTime = $NextTime.AddMinutes($minute - $NextTime.Minute)
}
# check hour
if (!$Expression.Hour.WildCard) {
$hour = Get-ClosestValue -AtomContraint $Expression.Hour -NowValue $NextTime.Hour
if ($hour -lt $NextTime.Hour) {
$NextTime = $NextTime.AddDays(1)
}
$_hour = $NextTime.Hour
$NextTime = $NextTime.AddHours($hour - $NextTime.Hour)
if ($_hour -ne $hour) {
$NextTime = [datetime]::new($NextTime.Year, $NextTime.Month, $NextTime.Day, $NextTime.Hour, 0, 0)
continue
}
}
# check day
if (!$Expression.DayOfMonth.WildCard) {
$day = Get-ClosestValue -AtomContraint $Expression.DayOfMonth -NowValue $NextTime.Day
if (($day -lt $NextTime.Day) -or ($day -gt [datetime]::DaysInMonth($NextTime.Year, $NextTime.Month))) {
$NextTime = $NextTime.AddMonths(1)
}
if ($day -gt [datetime]::DaysInMonth($NextTime.Year, $NextTime.Month)) {
$NextTime = [datetime]::new($NextTime.Year, $NextTime.Month, 1, 0, 0, 0)
continue
}
$_day = $NextTime.Day
$NextTime = $NextTime.AddDays($day - $NextTime.Day)
if ($_day -ne $day) {
$NextTime = [datetime]::new($NextTime.Year, $NextTime.Month, $NextTime.Day, 0, 0, 0)
continue
}
}
# check month
if (!$Expression.Month.WildCard) {
$month = Get-ClosestValue -AtomContraint $Expression.Month -NowValue $NextTime.Month
if ($month -lt $NextTime.Month) {
$NextTime = $NextTime.AddYears(1)
}
$_month = $NextTime.Month
$NextTime = $NextTime.AddMonths($month - $NextTime.Month)
if ($_month -ne $month) {
$NextTime = [datetime]::new($NextTime.Year, $NextTime.Month, 1, 0, 0, 0)
continue
}
}
# check day of week
if (!$Expression.DayOfWeek.WildCard) {
$doweek = Get-ClosestValue -AtomContraint $Expression.DayOfWeek -NowValue $NextTime.DayOfWeek
$_doweek = $NextTime.DayOfWeek
if ($doweek -lt $NextTime.DayOfWeek) {
$NextTime = $NextTime.AddDays(7 - ($NextTime.DayOfWeek - $doweek))
}
elseif ($doweek -gt $NextTime.DayOfWeek) {
$NextTime = $NextTime.AddDays($doweek - $NextTime.DayOfWeek)
}
if ($_doweek -ne $doweek) {
$NextTime = [datetime]::new($NextTime.Year, $NextTime.Month, $NextTime.Day, 0, 0, 0)
continue
}
}
break
}
# before we return, make sure the time is valid
if (!(Test-PodeCronExpression -Expression $Expression -DateTime $NextTime)) {
throw "Looks like something went wrong trying to calculate the next trigger datetime: $($NextTime)"
}
# if before the start or after end then return null
if (($NextTime -lt $StartTime) -or (($null -ne $EndTime) -and ($NextTime -gt $EndTime))) {
return $null
}
return $NextTime
}
function Invoke-PodeHMACSHA256Hash
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Value,
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Secret
)
$crypto = [System.Security.Cryptography.HMACSHA256]::new([System.Text.Encoding]::UTF8.GetBytes($Secret))
return [System.Convert]::ToBase64String($crypto.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($Value)))
}
function Invoke-PodeSHA256Hash
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Value
)
$crypto = [System.Security.Cryptography.SHA256]::Create()
return [System.Convert]::ToBase64String($crypto.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($Value)))
}
function Invoke-PodeSHA1Hash
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Value
)
$crypto = [System.Security.Cryptography.SHA1]::Create()
return [System.Convert]::ToBase64String($crypto.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($Value)))
}
function ConvertTo-PodeBase64Auth
{
param(
[Parameter(Mandatory=$true)]
[string]
$Username,
[Parameter(Mandatory=$true)]
[string]
$Password
)
return [System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes("$($Username):$($Password)"))
}
function Invoke-PodeMD5Hash
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Value
)
$crypto = [System.Security.Cryptography.MD5]::Create()
return [System.BitConverter]::ToString($crypto.ComputeHash([System.Text.Encoding]::ASCII.GetBytes($Value))).Replace('-', '').ToLowerInvariant()
}
function Get-PodeRandomBytes
{
param (
[Parameter()]
[int]
$Length = 16
)
return (Use-PodeStream -Stream ([System.Security.Cryptography.RandomNumberGenerator]::Create()) {
param($p)
$bytes = [byte[]]::new($Length)
$p.GetBytes($bytes)
return $bytes
})
}
function New-PodeSalt
{
param (
[Parameter()]
[int]
$Length = 8
)
$bytes = [byte[]](Get-PodeRandomBytes -Length $Length)
return [System.Convert]::ToBase64String($bytes)
}
function New-PodeGuid
{
param (
[Parameter()]
[int]
$Length = 16,
[switch]
$Secure,
[switch]
$NoDashes
)
# generate a cryptographically secure guid
if ($Secure) {
$bytes = [byte[]](Get-PodeRandomBytes -Length $Length)
$guid = ([guid]::new($bytes)).ToString()
}
# return a normal guid
else {
$guid = ([guid]::NewGuid()).ToString()
}
if ($NoDashes) {
$guid = ($guid -ireplace '-', '')
}
return $guid
}
function Invoke-PodeValueSign
{
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Value,
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Secret
)
return "s:$($Value).$(Invoke-PodeHMACSHA256Hash -Value $Value -Secret $Secret)"
}
function Invoke-PodeValueUnsign
{
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Value,
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Secret
)
# the signed value must start with "s:"
if (!$Value.StartsWith('s:')) {
return $null
}
# the signed value mised contain a dot - splitting value and signature
$Value = $Value.Substring(2)
$periodIndex = $Value.LastIndexOf('.')
if ($periodIndex -eq -1) {
return $null
}
# get the raw value and signature
$raw = $Value.Substring(0, $periodIndex)
$sig = $Value.Substring($periodIndex + 1)
if ((Invoke-PodeHMACSHA256Hash -Value $raw -Secret $Secret) -ne $sig) {
return $null
}
return $raw
}
function Find-PodeEndpoints
{
param(
[Parameter()]
[ValidateSet('', 'Http', 'Https')]
[string]
$Protocol,
[Parameter()]
[string]
$Address,
[Parameter()]
[string[]]
$EndpointName
)
$endpoints = @()
# just use a single endpoint/protocol
if ([string]::IsNullOrWhiteSpace($EndpointName)) {
$endpoints += @{
Protocol = $Protocol
Address = $Address
Name = [string]::Empty
}
}
# get all defined endpoints by name
else {
foreach ($name in @($EndpointName)) {
$_endpoint = Get-PodeEndpointByName -Name $name -ThrowError
if ($null -ne $_endpoint) {
$endpoints += @{
Protocol = $_endpoint.Protocol
Address = $_endpoint.RawAddress
Name = $name
}
}
}
}
# convert the endpoint's address into host:port format
foreach ($_endpoint in $endpoints) {
if (![string]::IsNullOrWhiteSpace($_endpoint.Address)) {
$_addr = Get-PodeEndpointInfo -Address $_endpoint.Address -AnyPortOnZero
$_endpoint.Address = "$($_addr.Host):$($_addr.Port)"
}
}
return $endpoints
}
function Get-PodeEndpoints
{
param(
[Parameter(Mandatory=$true)]
[ValidateSet('Http', 'Ws', 'Smtp', 'Tcp')]
[string]
$Type
)
$endpoints = $null
switch ($Type.ToLowerInvariant()) {
'http' {
$endpoints = @($PodeContext.Server.Endpoints.Values | Where-Object { @('http', 'https') -icontains $_.Protocol })
}
'ws' {
$endpoints = @($PodeContext.Server.Endpoints.Values | Where-Object { @('ws', 'wss') -icontains $_.Protocol })
}
'smtp' {
$endpoints = @($PodeContext.Server.Endpoints.Values | Where-Object { @('smtp') -icontains $_.Protocol })
}
'tcp' {
$endpoints = @($PodeContext.Server.Endpoints.Values | Where-Object { @('tcp') -icontains $_.Protocol })
}
}
return $endpoints
}
function Test-PodeEndpoints
{
param(
[Parameter(Mandatory=$true)]
[ValidateSet('Http', 'Ws', 'Smtp', 'Tcp')]
[string]
$Type
)
$endpoints = (Get-PodeEndpoints -Type $Type)
return (($null -ne $endpoints) -and ($endpoints.Length -gt 0))
}
function Find-PodeEndpointName
{
param(
[Parameter()]
[string]
$Protocol,
[Parameter()]
[string]
$Address,
[Parameter()]
[System.Net.EndPoint]
$LocalAddress,
[switch]
$Force,
[switch]
$ThrowError
)
if (!$PodeContext.Server.FindRouteEndpoint -and !$Force) {
return $null
}
if ([string]::IsNullOrWhiteSpace($Protocol) -or
[string]::IsNullOrWhiteSpace($Address) -or
[string]::IsNullOrWhiteSpace($LocalAddress)) {
return $null
}
<#
using Host header
#>
# add a default port to the address if missing
if (!$Address.Contains(':')) {
$port = Get-PodeDefaultPort -Protocol $Protocol -Real
$Address = "$($Address):$($port)"
}
# change localhost/computer name to ip address
if (($Address -ilike 'localhost:*') -or ($Address -ilike "$($PodeContext.Server.ComputerName):*")) {
$Address = ($Address -ireplace "(localhost|$([regex]::Escape($PodeContext.Server.ComputerName)))\:", "(127\.0\.0\.1|0\.0\.0\.0|localhost|$([regex]::Escape($PodeContext.Server.ComputerName))):")
}
else {
$Address = [regex]::Escape($Address)
}
# create the endpoint key for address
$key = "$($Protocol)\|$($Address)"
# try and find endpoint for address
$key = @(foreach ($k in $PodeContext.Server.EndpointsMap.Keys) {
if ($k -imatch $key) {
$k
break
}
})[0]
if (![string]::IsNullOrWhiteSpace($key) -and $PodeContext.Server.EndpointsMap.ContainsKey($key)) {
return $PodeContext.Server.EndpointsMap[$key]
}
<#
using local endpoint from socket
#>
# setup the local address as a string
$_localAddress = "$($LocalAddress.Address.IPAddressToString):$($LocalAddress.Port)"
$_localAddress = [regex]::Escape($_localAddress)
# create the endpoint key for local address
$key = "$($Protocol)\|$($_localAddress)"
# try and find endpoint for local address
$key = @(foreach ($k in $PodeContext.Server.EndpointsMap.Keys) {
if ($k -imatch $key) {
$k
break
}
})[0]
if (![string]::IsNullOrWhiteSpace($key) -and $PodeContext.Server.EndpointsMap.ContainsKey($key)) {
return $PodeContext.Server.EndpointsMap[$key]
}
<#
check for * address
#>
# set * address as string
$_anyAddress = "0\.0\.0\.0:$($LocalAddress.Port)"
$key = "$($Protocol)\|$($_anyAddress)"
# try and find endpoint for any address
$key = @(foreach ($k in $PodeContext.Server.EndpointsMap.Keys) {
if ($k -imatch $key) {
$k
break
}
})[0]
if (![string]::IsNullOrWhiteSpace($key) -and $PodeContext.Server.EndpointsMap.ContainsKey($key)) {
return $PodeContext.Server.EndpointsMap[$key]
}
# error?
if ($ThrowError) {
throw "Endpoint with protocol '$($Protocol)' and address '$($Address)' or local address '$($_localAddress)' does not exist"
}
return $null
}
function Get-PodeEndpointByName
{
param (
[Parameter()]
[string]
$Name,
[switch]
$ThrowError
)
# if an EndpointName was supplied, find it and use it
if ([string]::IsNullOrWhiteSpace($Name)) {
return $null
}
# ensure it exists
if ($PodeContext.Server.Endpoints.ContainsKey($Name)) {
return $PodeContext.Server.Endpoints[$Name]
}
# error?
if ($ThrowError) {
throw "Endpoint with name '$($Name)' does not exist"
}
return $null
}
function Invoke-PodeEndware
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$WebEvent,
[Parameter()]
$Endware
)
# if there's no endware, do nothing
if (($null -eq $Endware) -or ($Endware.Length -eq 0)) {
return
}
# loop through each of the endware, invoking the next if it returns true
foreach ($eware in @($Endware))
{
if (($null -eq $eware) -or ($null -eq $eware.Logic)) {
continue
}
try {
$_args = @($eware.Arguments)
if ($null -ne $eware.UsingVariables) {
$_vars = @()
foreach ($_var in $eware.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
Invoke-PodeScriptBlock -ScriptBlock $eware.Logic -Arguments $_args -Scoped -Splat | Out-Null
}
catch {
$_ | Write-PodeErrorLog
}
}
}
function Start-PodeFileMonitor
{
# don't configure if not supplied, or we're running as serverless
if (!$PodeContext.Server.FileMonitor.Enabled -or $PodeContext.Server.IsServerless) {
return
}
# what folder and filter are we moitoring?
$folder = $PodeContext.Server.Root
$filter = '*.*'
# setup the file monitor
$watcher = New-Object System.IO.FileSystemWatcher $folder, $filter -Property @{
IncludeSubdirectories = $true;
NotifyFilter = [System.IO.NotifyFilters]'FileName,LastWrite,CreationTime';
}
$watcher.EnableRaisingEvents = $true
# setup the monitor timer - only restart server after changes + 2s of no changes
$timer = New-Object System.Timers.Timer
$timer.AutoReset = $false
$timer.Interval = 2000
# setup the message data for the events
$msgData = @{
Timer = $timer
Settings = $PodeContext.Server.FileMonitor
}
# setup the events script logic
$action = {
# if there are exclusions, and one matches, return
if (($null -ne $Event.MessageData.Settings.Exclude) -and ($Event.SourceEventArgs.Name -imatch $Event.MessageData.Settings.Exclude)) {
return
}
# if there are inclusions, and none match, return
if (($null -ne $Event.MessageData.Settings.Include) -and ($Event.SourceEventArgs.Name -inotmatch $Event.MessageData.Settings.Include)) {
return
}
# if enabled, add the file to the list of files that trigggered the restart
if ($Event.MessageData.Settings.ShowFiles) {
$name = "[$($Event.SourceEventArgs.ChangeType)] $($Event.SourceEventArgs.Name)"
if ($Event.MessageData.Settings.Files -inotcontains $name) {
$Event.MessageData.Settings.Files += $name
}
}
# restart the timer
$Event.MessageData.Timer.Stop()
$Event.MessageData.Timer.Start()
}
# listen out of file created, changed, deleted events
Register-ObjectEvent -InputObject $watcher -EventName 'Created' `
-SourceIdentifier (Get-PodeFileMonitorName Create) -Action $action -MessageData $msgData -SupportEvent
Register-ObjectEvent -InputObject $watcher -EventName 'Changed' `
-SourceIdentifier (Get-PodeFileMonitorName Update) -Action $action -MessageData $msgData -SupportEvent
Register-ObjectEvent -InputObject $watcher -EventName 'Deleted' `
-SourceIdentifier (Get-PodeFileMonitorName Delete) -Action $action -MessageData $msgData -SupportEvent
# listen out for timer ticks to reset server
Register-ObjectEvent -InputObject $timer -EventName 'Elapsed' -SourceIdentifier (Get-PodeFileMonitorTimerName) -Action {
# if enabled, show the files that triggered the restart
if ($Event.MessageData.FileSettings.ShowFiles) {
if (!$Event.MessageData.Quiet) {
Write-Host 'The following files have changed:' -ForegroundColor Magenta
foreach ($file in $Event.MessageData.FileSettings.Files) {
Write-Host "> $($file)" -ForegroundColor Magenta
}
}
$Event.MessageData.FileSettings.Files = @()
}
# trigger the restart
$Event.MessageData.Tokens.Restart.Cancel()
$Event.Sender.Stop()
} -MessageData @{
Tokens = $PodeContext.Tokens
FileSettings = $PodeContext.Server.FileMonitor
Quiet = $PodeContext.Server.Quiet
} -SupportEvent
}
function Stop-PodeFileMonitor
{
if ($PodeContext.Server.IsServerless) {
return
}
if ($PodeContext.Server.FileMonitor.Enabled) {
Unregister-Event -SourceIdentifier (Get-PodeFileMonitorName Create) -Force
Unregister-Event -SourceIdentifier (Get-PodeFileMonitorName Delete) -Force
Unregister-Event -SourceIdentifier (Get-PodeFileMonitorName Update) -Force
Unregister-Event -SourceIdentifier (Get-PodeFileMonitorTimerName) -Force
}
}
function Get-PodeFileMonitorName
{
param (
[Parameter(Mandatory=$true)]
[ValidateSet('Create', 'Delete', 'Update')]
[string]
$Type
)
return "PodeFileMonitor$($Type)"
}
function Get-PodeFileMonitorTimerName
{
return 'PodeFileMonitorTimer'
}
function Start-PodeGuiRunspace {
# do nothing if gui not enabled, or running as serverless
if (!$PodeContext.Server.Gui.Enabled -or
$PodeContext.Server.IsServerless -or
$PodeContext.Server.IsIIS -or
$PodeContext.Server.IsHeroku) {
return
}
$script = {
try {
# if there are multiple endpoints, flag warning we're only using the first - unless explicitly set
if ($null -eq $PodeContext.Server.Gui.Endpoint) {
if ($PodeContext.Server.Endpoints.Values.Count -gt 1) {
Write-PodeHost "Multiple endpoints defined, only the first will be used for the GUI" -ForegroundColor Yellow
}
}
# get the endpoint on which we're currently listening, or use explicitly passed one
$uri = (Get-PodeEndpointUrl -Endpoint $PodeContext.Server.Gui.Endpoint)
# poll the server for a response
$count = 0
while ($true) {
try {
Invoke-WebRequest -Method Get -Uri $uri -UseBasicParsing -ErrorAction Stop | Out-Null
if (!$?) {
throw
}
break
}
catch {
$count++
if ($count -le 50) {
Start-Sleep -Milliseconds 200
}
else {
throw "Failed to connect to URL: $($uri)"
}
}
}
# import the WPF assembly
[System.Reflection.Assembly]::LoadWithPartialName('PresentationFramework') | Out-Null
[System.Reflection.Assembly]::LoadWithPartialName('PresentationCore') | Out-Null
# Check for CefSharp
$loadCef = [bool]([AppDomain]::CurrentDomain.GetAssemblies() | Where-Object { $_.FullName.StartsWith("CefSharp.Wpf,") })
# setup the WPF XAML for the server
# Check for CefSharp and used Chromium based WPF if Modules exists
if ($loadCef) {
$gui_browser = "
<Window
xmlns=`"http://schemas.microsoft.com/winfx/2006/xaml/presentation`"
xmlns:wpf=`"clr-namespace:CefSharp.Wpf;assembly=CefSharp.Wpf`"
xmlns:x=`"http://schemas.microsoft.com/winfx/2006/xaml`"
Title=`"$($PodeContext.Server.Gui.Title)`"
Height=`"$($PodeContext.Server.Gui.Height)`"
Width=`"$($PodeContext.Server.Gui.Width)`"
ResizeMode=`"$($PodeContext.Server.Gui.ResizeMode)`"
WindowStartupLocation=`"CenterScreen`"
ShowInTaskbar = `"$($PodeContext.Server.Gui.ShowInTaskbar)`"
WindowStyle = `"$($PodeContext.Server.Gui.WindowStyle)`">
<Window.TaskbarItemInfo>
<TaskbarItemInfo />
</Window.TaskbarItemInfo>
<Border Grid.Row=`"1`" BorderBrush=`"Gray`" BorderThickness=`"0,1`">
<wpf:ChromiumWebBrowser x:Name=`"Browser`" Address=`"$uri`"/>
</Border>
</Window>"
}
else {
# Fall back to the IE based WPF Browser
$gui_browser = "
<Window
xmlns=`"http://schemas.microsoft.com/winfx/2006/xaml/presentation`"
xmlns:x=`"http://schemas.microsoft.com/winfx/2006/xaml`"
Title=`"$($PodeContext.Server.Gui.Title)`"
Height=`"$($PodeContext.Server.Gui.Height)`"
Width=`"$($PodeContext.Server.Gui.Width)`"
ResizeMode=`"$($PodeContext.Server.Gui.ResizeMode)`"
WindowStartupLocation=`"CenterScreen`"
ShowInTaskbar = `"$($PodeContext.Server.Gui.ShowInTaskbar)`"
WindowStyle = `"$($PodeContext.Server.Gui.WindowStyle)`">
<Window.TaskbarItemInfo>
<TaskbarItemInfo />
</Window.TaskbarItemInfo>
<WebBrowser Name=`"WebBrowser`"></WebBrowser>
</Window>"
}
# read in the XAML
$reader = [System.Xml.XmlNodeReader]::new([xml]$gui_browser)
$form = [Windows.Markup.XamlReader]::Load($reader)
# set other options
$form.TaskbarItemInfo.Description = $form.Title
# add the icon to the form
if (!(Test-PodeIsEmpty $PodeContext.Server.Gui.Icon)) {
$icon = [Uri]::new($PodeContext.Server.Gui.Icon)
$form.Icon = [Windows.Media.Imaging.BitmapFrame]::Create($icon)
}
# set the state of the window onload
if (!(Test-PodeIsEmpty $PodeContext.Server.Gui.WindowState)) {
$form.WindowState = $PodeContext.Server.Gui.WindowState
}
# get the browser object from XAML and navigate to base page if Cef is not loaded
if (!$loadCef) {
$form.FindName("WebBrowser").Navigate($uri)
}
# display the form
$form.ShowDialog() | Out-Null
Start-Sleep -Seconds 1
}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
finally {
# invoke the cancellation token to close the server
$PodeContext.Tokens.Cancellation.Cancel()
}
}
Add-PodeRunspace -Type Gui -ScriptBlock $script
}
# read in the content from a dynamic pode file and invoke its content
function ConvertFrom-PodeFile
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Content,
[Parameter()]
$Data = @{}
)
# if we have data, then setup the data param
if ($null -ne $Data -and $Data.Count -gt 0) {
$Content = "param(`$data)`nreturn `"$($Content -replace '"', '``"')`""
}
else {
$Content = "return `"$($Content -replace '"', '``"')`""
}
# invoke the content as a script to generate the dynamic content
return (Invoke-PodeScriptBlock -ScriptBlock ([scriptblock]::Create($Content)) -Arguments $Data -Return)
}
function Get-PodeViewEngineType
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path
)
# work out the engine to use when parsing the file
$type = $PodeContext.Server.ViewEngine.Type
$ext = Get-PodeFileExtension -Path $Path -TrimPeriod
if (![string]::IsNullOrWhiteSpace($ext) -and ($ext -ine $PodeContext.Server.ViewEngine.Extension)) {
$type = $ext
}
return $type
}
function Get-PodeFileContentUsingViewEngine
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[hashtable]
$Data
)
# work out the engine to use when parsing the file
$engine = Get-PodeViewEngineType -Path $Path
# setup the content
$content = [string]::Empty
# run the relevant engine logic
switch ($engine.ToLowerInvariant())
{
'html' {
$content = Get-Content -Path $Path -Raw -Encoding utf8
}
'md' {
$content = Get-Content -Path $Path -Raw -Encoding utf8
}
'pode' {
$content = Get-Content -Path $Path -Raw -Encoding utf8
$content = ConvertFrom-PodeFile -Content $content -Data $Data
}
default {
if ($null -ne $PodeContext.Server.ViewEngine.ScriptBlock) {
$_args = @($Path)
if (($null -ne $Data) -and ($Data.Count -gt 0)) {
$_args = @($Path, $Data)
}
if ($null -ne $PodeContext.Server.ViewEngine.UsingVariables) {
$_vars = @()
foreach ($_var in $PodeContext.Server.ViewEngine.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
$content = (Invoke-PodeScriptBlock -ScriptBlock $PodeContext.Server.ViewEngine.ScriptBlock -Arguments $_args -Return -Splat)
}
}
}
return $content
}
function Get-PodeFileContent
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path
)
return (Get-Content -Path $Path -Raw -Encoding utf8)
}
function Get-PodeType
{
param (
[Parameter()]
$Value
)
if ($null -eq $Value) {
return $null
}
$type = $Value.GetType()
return @{
'Name' = $type.Name.ToLowerInvariant();
'BaseName' = $type.BaseType.Name.ToLowerInvariant();
}
}
function Get-PodePSVersionTable
{
return $PSVersionTable
}
function Test-PodeIsAdminUser
{
# check the current platform, if it's unix then return true
if (Test-PodeIsUnix) {
return $true
}
try {
$principal = New-Object System.Security.Principal.WindowsPrincipal([System.Security.Principal.WindowsIdentity]::GetCurrent())
if ($null -eq $principal) {
return $false
}
return $principal.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
}
catch [exception] {
Write-PodeHost 'Error checking user administrator priviledges' -ForegroundColor Red
Write-PodeHost $_.Exception.Message -ForegroundColor Red
return $false
}
}
function Get-PodeHostIPRegex
{
param (
[Parameter(Mandatory=$true)]
[ValidateSet('Both', 'Hostname', 'IP')]
[string]
$Type
)
$ip_rgx = '\[[a-f0-9\:]+\]|((\d+\.){3}\d+)|\:\:\d+|\*|all'
$host_rgx = '([a-z]|\*\.)(([a-z0-9]|[a-z0-9][a-z0-9\-]*[a-z0-9])\.)*([a-z0-9]|[a-z0-9][a-z0-9\-]*[a-z0-9])+'
switch ($Type.ToLowerInvariant())
{
'both' {
return "(?<host>($($ip_rgx)|$($host_rgx)))"
}
'hostname' {
return "(?<host>($($host_rgx)))"
}
'ip' {
return "(?<host>($($ip_rgx)))"
}
}
}
function Get-PortRegex
{
return '(?<port>\d+)'
}
function Get-PodeEndpointInfo
{
param (
[Parameter()]
[string]
$Address,
[switch]
$AnyPortOnZero
)
if ([string]::IsNullOrWhiteSpace($Address)) {
return $null
}
$hostRgx = Get-PodeHostIPRegex -Type Both
$portRgx = Get-PortRegex
$cmbdRgx = "$($hostRgx)\:$($portRgx)"
# validate that we have a valid ip/host:port address
if (!(($Address -imatch "^$($cmbdRgx)$") -or ($Address -imatch "^$($hostRgx)[\:]{0,1}") -or ($Address -imatch "[\:]{0,1}$($portRgx)$"))) {
throw "Failed to parse '$($Address)' as a valid IP/Host:Port address"
}
# grab the ip address/hostname
$_host = $Matches['host']
if ([string]::IsNullOrWhiteSpace($_host)) {
$_host = '*'
}
# ensure we have a valid ip address/hostname
if (!(Test-PodeIPAddress -IP $_host)) {
throw "The IP address supplied is invalid: $($_host)"
}
# grab the port
$_port = $Matches['port']
if ([string]::IsNullOrWhiteSpace($_port)) {
$_port = 0
}
# ensure the port is valid
if ($_port -lt 0) {
throw "The port cannot be negative: $($_port)"
}
# return the info
return @{
Host = $_host
Port = (Resolve-PodeValue -Check ($AnyPortOnZero -and ($_port -eq 0)) -TrueValue '*' -FalseValue $_port)
}
}
function Test-PodeIPAddress
{
param (
[Parameter()]
[string]
$IP,
[switch]
$IPOnly
)
if ([string]::IsNullOrWhiteSpace($IP) -or ($IP -ieq '*') -or ($IP -ieq 'all')) {
return $true
}
if ($IP -imatch "^$(Get-PodeHostIPRegex -Type Hostname)$") {
return (!$IPOnly)
}
try {
[System.Net.IPAddress]::Parse($IP) | Out-Null
return $true
}
catch [exception] {
return $false
}
}
function Test-PodeHostname
{
param (
[Parameter()]
[string]
$Hostname
)
return ($Hostname -imatch "^$(Get-PodeHostIPRegex -Type Hostname)$")
}
function ConvertTo-PodeIPAddress
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Address
)
return [System.Net.IPAddress]::Parse(([System.Net.IPEndPoint]$Address).Address.ToString())
}
function Get-PodeIPAddressesForHostname
{
param (
[Parameter(Mandatory=$true)]
[string]
$Hostname,
[Parameter(Mandatory=$true)]
[ValidateSet('All', 'IPv4', 'IPv6')]
[string]
$Type
)
if (!(Test-PodeHostname -Hostname $Hostname)) {
return $Hostname
}
# get the ip addresses for the hostname
try {
$ips = @([System.Net.Dns]::GetHostAddresses($Hostname))
}
catch {
return '127.0.0.1'
}
# return ips based on type
switch ($Type.ToLowerInvariant())
{
'ipv4' {
$ips = @(foreach ($ip in $ips) {
if ($ip.AddressFamily -ieq 'InterNetwork') {
$ip
}
})
}
'ipv6' {
$ips = @(foreach ($ip in $ips) {
if ($ip.AddressFamily -ieq 'InterNetworkV6') {
$ip
}
})
}
}
return (@($ips)).IPAddressToString
}
function Test-PodeIPAddressLocal
{
param (
[Parameter(Mandatory=$true)]
[string]
$IP
)
return (@('127.0.0.1', '::1', '[::1]', 'localhost') -icontains $IP)
}
function Test-PodeIPAddressAny
{
param (
[Parameter(Mandatory=$true)]
[string]
$IP
)
return (@('0.0.0.0', '*', 'all', '::', '[::]') -icontains $IP)
}
function Test-PodeIPAddressLocalOrAny
{
param (
[Parameter(Mandatory=$true)]
[string]
$IP
)
return ((Test-PodeIPAddressLocal -IP $IP) -or (Test-PodeIPAddressAny -IP $IP))
}
function Get-PodeIPAddress
{
param (
[Parameter()]
[string]
$IP
)
# any address for IPv4
if ([string]::IsNullOrWhiteSpace($IP) -or ($IP -ieq '*') -or ($IP -ieq 'all')) {
return [System.Net.IPAddress]::Any
}
# any address for IPv6
if (($IP -ieq '::') -or ($IP -ieq '[::]')) {
return [System.Net.IPAddress]::IPv6Any
}
# localhost
if ($IP -ieq 'localhost') {
return [System.Net.IPAddress]::Loopback
}
# hostname
if ($IP -imatch "^$(Get-PodeHostIPRegex -Type Hostname)$") {
return $IP
}
# raw ip
return [System.Net.IPAddress]::Parse($IP)
}
function Test-PodeIPAddressInRange
{
param (
[Parameter(Mandatory=$true)]
$IP,
[Parameter(Mandatory=$true)]
$LowerIP,
[Parameter(Mandatory=$true)]
$UpperIP
)
if ($IP.Family -ine $LowerIP.Family) {
return $false
}
$valid = $true
foreach ($i in 0..3) {
if (($IP.Bytes[$i] -lt $LowerIP.Bytes[$i]) -or ($IP.Bytes[$i] -gt $UpperIP.Bytes[$i])) {
$valid = $false
break
}
}
return $valid
}
function Test-PodeIPAddressIsSubnetMask
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$IP
)
return (($IP -split '/').Length -gt 1)
}
function Get-PodeSubnetRange
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$SubnetMask
)
# split for ip and number of 1 bits
$split = $SubnetMask -split '/'
if ($split.Length -le 1) {
return $null
}
$ip_parts = $split[0] -isplit '\.'
$bits = [int]$split[1]
# generate the netmask
$network = @("", "", "", "")
$count = 0
foreach ($i in 0..3) {
foreach ($b in 1..8) {
$count++
if ($count -le $bits) {
$network[$i] += "1"
}
else {
$network[$i] += "0"
}
}
}
# covert netmask to bytes
foreach ($i in 0..3) {
$network[$i] = [Convert]::ToByte($network[$i], 2)
}
# calculate the bottom range
$bottom = @(foreach ($i in 0..3) {
[byte]([byte]$network[$i] -band [byte]$ip_parts[$i])
})
# calculate the range
$range = @(foreach ($i in 0..3) {
256 + (-bnot [byte]$network[$i])
})
# calculate the top range
$top = @(foreach ($i in 0..3) {
[byte]([byte]$ip_parts[$i] + [byte]$range[$i])
})
return @{
'Lower' = ($bottom -join '.');
'Upper' = ($top -join '.');
'Range' = ($range -join '.');
'Netmask' = ($network -join '.');
'IP' = ($ip_parts -join '.');
}
}
function Add-PodeRunspace
{
param (
[Parameter(Mandatory=$true)]
[ValidateSet('Main', 'Signals', 'Schedules', 'Gui', 'Web', 'Smtp', 'Tcp')]
[string]
$Type,
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[scriptblock]
$ScriptBlock,
[Parameter()]
$Parameters,
[switch]
$Forget
)
try
{
$ps = [powershell]::Create()
$ps.RunspacePool = $PodeContext.RunspacePools[$Type]
$ps.AddScript({ Add-PodePSDrives }) | Out-Null
$ps.AddScript($ScriptBlock) | Out-Null
if (!(Test-PodeIsEmpty $Parameters)) {
$Parameters.Keys | ForEach-Object {
$ps.AddParameter($_, $Parameters[$_]) | Out-Null
}
}
if ($Forget) {
$ps.BeginInvoke() | Out-Null
}
else {
$PodeContext.Runspaces += @{
Pool = $Type
Runspace = $ps
Status = $ps.BeginInvoke()
Stopped = $false
}
}
}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
}
function Close-PodeRunspaces
{
param (
[switch]
$ClosePool
)
if ($PodeContext.Server.IsServerless) {
return
}
try {
if (!(Test-PodeIsEmpty $PodeContext.Runspaces)) {
# wait until listeners are disposed
$count = 0
$continue = $false
while ($count -le 10) {
Start-Sleep -Seconds 1
$count++
$continue = $false
foreach ($listener in $PodeContext.Listeners) {
if (!$listener.IsDisposed) {
$continue = $true
break
}
}
if ($continue) {
continue
}
break
}
# now dispose runspaces
$PodeContext.Runspaces | Where-Object { !$_.Stopped } | ForEach-Object {
Close-PodeDisposable -Disposable $_.Runspace
$_.Stopped = $true
}
$PodeContext.Runspaces = @()
}
# dispose the runspace pools
if ($ClosePool -and $null -ne $PodeContext.RunspacePools) {
$PodeContext.RunspacePools.Values | Where-Object { $null -ne $_ -and !$_.IsDisposed } | ForEach-Object {
Close-PodeDisposable -Disposable $_ -Close
}
}
}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
}
function Get-PodeConsoleKey
{
if ([Console]::IsInputRedirected -or ![Console]::KeyAvailable) {
return $null
}
return [Console]::ReadKey($true)
}
function Test-PodeTerminationPressed
{
param(
[Parameter()]
$Key = $null
)
if ($PodeContext.Server.DisableTermination) {
return $false
}
return (Test-PodeKeyPressed -Key $Key -Character 'c')
}
function Test-PodeRestartPressed
{
param(
[Parameter()]
$Key = $null
)
return (Test-PodeKeyPressed -Key $Key -Character 'r')
}
function Test-PodeOpenBrowserPressed
{
param(
[Parameter()]
$Key = $null
)
return (Test-PodeKeyPressed -Key $Key -Character 'b')
}
function Test-PodeKeyPressed
{
param(
[Parameter()]
$Key = $null,
[Parameter(Mandatory=$true)]
[string]
$Character
)
if ($null -eq $Key) {
$Key = Get-PodeConsoleKey
}
return (($null -ne $Key) -and ($Key.Key -ieq $Character) -and
(($Key.Modifiers -band [ConsoleModifiers]::Control) -or ((Test-PodeIsUnix) -and ($Key.Modifiers -band [ConsoleModifiers]::Shift))))
}
function Close-PodeServerInternal
{
param (
[switch]
$ShowDoneMessage
)
# ensure the token is cancelled
if ($null -ne $PodeContext.Tokens.Cancellation) {
$PodeContext.Tokens.Cancellation.Cancel()
}
# stop all current runspaces
Close-PodeRunspaces -ClosePool
# stop the file monitor if it's running
Stop-PodeFileMonitor
try {
# remove all the cancellation tokens
Close-PodeDisposable -Disposable $PodeContext.Tokens.Cancellation
Close-PodeDisposable -Disposable $PodeContext.Tokens.Restart
}
catch {
$_ | Write-PodeErrorLog
}
# remove all of the pode temp drives
Remove-PodePSDrives
if ($ShowDoneMessage -and ($PodeContext.Server.Types.Length -gt 0) -and !$PodeContext.Server.IsServerless) {
Write-PodeHost " Done" -ForegroundColor Green
}
}
function New-PodePSDrive
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[string]
$Name
)
# if the path is a share, do nothing
if ($Path.StartsWith('\\')) {
return $Path
}
# if no name is passed, used a randomly generated one
if ([string]::IsNullOrWhiteSpace($Name)) {
$Name = "PodeDir$(New-PodeGuid)"
}
# if the path supplied doesn't exist, error
if (!(Test-Path $Path)) {
throw "Path does not exist: $($Path)"
}
# create the temp drive
$drive = (New-PSDrive -Name $Name -PSProvider FileSystem -Root $Path -Scope Global)
# store internally, and return the drive's name
if (!$PodeContext.Server.Drives.ContainsKey($drive.Name)) {
$PodeContext.Server.Drives[$drive.Name] = $Path
}
return "$($drive.Name):"
}
function Add-PodePSDrives
{
$PodeContext.Server.Drives.Keys | ForEach-Object {
New-PodePSDrive -Path $PodeContext.Server.Drives[$_] -Name $_ | Out-Null
}
}
function Add-PodePSInbuiltDrives
{
# create drive for views, if path exists
$path = (Join-PodeServerRoot 'views')
if (Test-Path $path) {
$PodeContext.Server.InbuiltDrives['views'] = (New-PodePSDrive -Path $path)
}
# create drive for public content, if path exists
$path = (Join-PodeServerRoot 'public')
if (Test-Path $path) {
$PodeContext.Server.InbuiltDrives['public'] = (New-PodePSDrive -Path $path)
}
# create drive for errors, if path exists
$path = (Join-PodeServerRoot 'errors')
if (Test-Path $path) {
$PodeContext.Server.InbuiltDrives['errors'] = (New-PodePSDrive -Path $path)
}
}
function Remove-PodePSDrives
{
Get-PSDrive PodeDir* | Remove-PSDrive | Out-Null
}
function Join-PodeServerRoot
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Folder,
[Parameter()]
[string]
$FilePath,
[Parameter()]
[string]
$Root
)
# use the root path of the server
if ([string]::IsNullOrWhiteSpace($Root)) {
$Root = $PodeContext.Server.Root
}
# join the folder/file to the root path
return (Join-PodePaths @($Root, $Folder, $FilePath))
}
function Remove-PodeEmptyItemsFromArray
{
param (
[Parameter(ValueFromPipeline=$true)]
$Array
)
if ($null -eq $Array) {
return @()
}
return @(@($Array -ne ([string]::Empty)) -ne $null)
}
function Remove-PodeNullKeysFromHashtable
{
param(
[Parameter(ValueFromPipeline=$true)]
[hashtable]
$Hashtable
)
foreach ($key in ($Hashtable.Clone()).Keys) {
if ($null -eq $Hashtable[$key]) {
$Hashtable.Remove($key) | Out-Null
}
if (($Hashtable[$key] -is [array]) -and ($Hashtable[$key].Length -eq 1) -and ($null -eq $Hashtable[$key][0])) {
$Hashtable.Remove($key) | Out-Null
}
if ($Hashtable[$key] -is [hashtable]) {
$Hashtable[$key] | Remove-PodeNullKeysFromHashtable
}
}
}
function Join-PodePaths
{
param (
[Parameter()]
[string[]]
$Paths
)
return [System.IO.Path]::Combine($Paths)
}
function Get-PodeFileExtension
{
param (
[Parameter()]
[string]
$Path,
[switch]
$TrimPeriod
)
$ext = [System.IO.Path]::GetExtension($Path)
if ($TrimPeriod) {
$ext = $ext.Trim('.')
}
return $ext
}
function Get-PodeFileName
{
param (
[Parameter()]
[string]
$Path,
[switch]
$WithoutExtension
)
if ($WithoutExtension) {
return [System.IO.Path]::GetFileNameWithoutExtension($Path)
}
return [System.IO.Path]::GetFileName($Path)
}
function Test-PodeValidNetworkFailure
{
param (
[Parameter()]
$Exception
)
$msgs = @(
'*network name is no longer available*',
'*nonexistent network connection*',
'*the response has completed*',
'*broken pipe*'
)
$match = @(foreach ($msg in $msgs) {
if ($Exception.Message -ilike $msg) {
$msg
}
})[0]
return ($null -ne $match)
}
function ConvertFrom-PodeHeaderQValue
{
param(
[Parameter(ValueFromPipeline=$true)]
[string]
$Value
)
$qs = [ordered]@{}
# return if no value
if ([string]::IsNullOrWhiteSpace($Value)) {
return $qs
}
# split the values up
$parts = @($Value -isplit ',').Trim()
# go through each part and check its q-value
foreach ($part in $parts) {
# default of 1 if no q-value
if ($part.IndexOf(';q=') -eq -1) {
$qs[$part] = 1.0
continue
}
# parse for q-value
$atoms = @($part -isplit ';q=')
$qs[$atoms[0]] = [double]$atoms[1]
}
return $qs
}
function Get-PodeAcceptEncoding
{
param(
[Parameter()]
[string]
$AcceptEncoding,
[switch]
$ThrowError
)
# return if no encoding
if ([string]::IsNullOrWhiteSpace($AcceptEncoding)) {
return [string]::Empty
}
# return empty if not compressing
if (!$PodeContext.Server.Web.Compression.Enabled) {
return [string]::Empty
}
# convert encoding form q-form
$encodings = ConvertFrom-PodeHeaderQValue -Value $AcceptEncoding
if ($encodings.Count -eq 0) {
return [string]::Empty
}
# check the encodings for one that matches
$normal = @('identity', '*')
$valid = @()
# build up supported and invalid
foreach ($encoding in $encodings.Keys) {
if (($encoding -iin $PodeContext.Server.Compression.Encodings) -or ($encoding -iin $normal)) {
$valid += @{
Name = $encoding
Value = $encodings[$encoding]
}
}
}
# if it's empty, just return empty
if ($valid.Length -eq 0) {
return [string]::Empty
}
# find the highest ranked match
$found = @{}
$failOnIdentity = $false
foreach ($encoding in $valid) {
if ($encoding.Value -gt $found.Value) {
$found = $encoding
}
if (!$failOnIdentity -and ($encoding.Value -eq 0) -and ($encoding.Name -iin $normal)) {
$failOnIdentity = $true
}
}
# force found to identity/* if the 0 is not identity - meaning it's still allowed
if (($found.Value -eq 0) -and !$failOnIdentity) {
$found = @{
Name = 'identity'
Value = 1.0
}
}
# return invalid, error, or return empty for idenity?
if ($found.Value -eq 0) {
if ($ThrowError) {
$err = [System.Net.Http.HttpRequestException]::new()
$err.Data.Add('PodeStatusCode', 406)
throw $err
}
}
# else, we're safe
if ($found.Name -iin $normal) {
return [string]::Empty
}
if ($found.Name -ieq 'x-gzip') {
return 'gzip'
}
return $found.Name
}
function Get-PodeTransferEncoding
{
param(
[Parameter()]
[string]
$TransferEncoding,
[switch]
$ThrowError
)
# return if no encoding
if ([string]::IsNullOrWhiteSpace($TransferEncoding)) {
return [string]::Empty
}
# convert encoding form q-form
$encodings = ConvertFrom-PodeHeaderQValue -Value $TransferEncoding
if ($encodings.Count -eq 0) {
return [string]::Empty
}
# check the encodings for one that matches
$normal = @('chunked', 'identity')
$invalid = @()
# if we see a supported one, return immediately. else build up invalid one
foreach ($encoding in $encodings.Keys) {
if ($encoding -iin $PodeContext.Server.Compression.Encodings) {
if ($encoding -ieq 'x-gzip') {
return 'gzip'
}
return $encoding
}
if ($encoding -iin $normal) {
continue
}
$invalid += $encoding
}
# if we have any invalid, throw a 415 error
if ($invalid.Length -gt 0) {
if ($ThrowError) {
$err = [System.Net.Http.HttpRequestException]::new()
$err.Data.Add('PodeStatusCode', 415)
throw $err
}
return $invalid[0]
}
# else, we're safe
return [string]::Empty
}
function Get-PodeEncodingFromContentType
{
param(
[Parameter()]
[string]
$ContentType
)
if ([string]::IsNullOrWhiteSpace($ContentType)) {
return [System.Text.Encoding]::UTF8
}
$parts = @($ContentType -isplit ';').Trim()
foreach ($part in $parts) {
if ($part.StartsWith('charset')) {
return [System.Text.Encoding]::GetEncoding(($part -isplit '=')[1].Trim())
}
}
return [System.Text.Encoding]::UTF8
}
function ConvertFrom-PodeRequestContent
{
param (
[Parameter()]
$Request,
[Parameter()]
[string]
$ContentType,
[Parameter()]
[string]
$TransferEncoding
)
# get the requests content type and boundary
$MetaData = Get-PodeContentTypeAndBoundary -ContentType $ContentType
$Encoding = $Request.ContentEncoding
# result object for data/files
$Result = @{
Data = @{}
Files = @{}
}
# if there is no content-type then do nothing
if ([string]::IsNullOrWhiteSpace($MetaData.ContentType)) {
return $Result
}
# if the content-type is not multipart/form-data, get the string data
if ($MetaData.ContentType -ine 'multipart/form-data') {
# get the content based on server type
if ($PodeContext.Server.IsServerless) {
switch ($PodeContext.Server.ServerlessType.ToLowerInvariant()) {
'awslambda' {
$Content = $Request.body
}
'azurefunctions' {
$Content = $Request.RawBody
}
}
}
else {
# if the request is compressed, attempt to uncompress it
if (![string]::IsNullOrWhiteSpace($TransferEncoding)) {
# create a compressed stream to decompress the req bytes
$ms = New-Object -TypeName System.IO.MemoryStream
$ms.Write($Request.RawBody, 0, $Request.RawBody.Length)
$ms.Seek(0, 0) | Out-Null
$stream = New-Object "System.IO.Compression.$($TransferEncoding)Stream"($ms, [System.IO.Compression.CompressionMode]::Decompress)
# read the decompressed bytes
$Content = Read-PodeStreamToEnd -Stream $stream -Encoding $Encoding
}
else {
$Content = $Request.Body
}
}
# if there is no content then do nothing
if ([string]::IsNullOrWhiteSpace($Content)) {
return $Result
}
# check if there is a defined custom body parser
if ($PodeContext.Server.BodyParsers.ContainsKey($MetaData.ContentType)) {
$parser = $PodeContext.Server.BodyParsers[$MetaData.ContentType]
$_args = @($Content)
if ($null -ne $parser.UsingVariables) {
$_vars = @()
foreach ($_var in $parser.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
$Result.Data = (Invoke-PodeScriptBlock -ScriptBlock $parser.ScriptBlock -Arguments $_args -Return)
$Content = $null
return $Result
}
}
# run action for the content type
switch ($MetaData.ContentType) {
{ $_ -ilike '*/json' } {
if (Test-PodeIsPSCore) {
$Result.Data = ($Content | ConvertFrom-Json -AsHashtable)
}
else {
$Result.Data = ($Content | ConvertFrom-Json)
}
}
{ $_ -ilike '*/xml' } {
$Result.Data = [xml]($Content)
}
{ $_ -ilike '*/csv' } {
$Result.Data = ($Content | ConvertFrom-Csv)
}
{ $_ -ilike '*/x-www-form-urlencoded' } {
$Result.Data = (ConvertFrom-PodeNameValueToHashTable -Collection ([System.Web.HttpUtility]::ParseQueryString($Content)))
}
{ $_ -ieq 'multipart/form-data' } {
# convert the stream to bytes
$Content = $Request.RawBody
if ($Content.Length -eq 0) {
$Content = ConvertFrom-PodeStreamToBytes -Stream $Request.InputStream
}
$Lines = Get-PodeByteLinesFromByteArray -Bytes $Content -Encoding $Encoding -IncludeNewLine
# get the indexes for boundary lines (start and end)
$boundaryIndexes = @()
for ($i = 0; $i -lt $Lines.Length; $i++) {
if ((Test-PodeByteArrayIsBoundary -Bytes $Lines[$i] -Boundary $MetaData.Boundary.Start -Encoding $Encoding) -or
(Test-PodeByteArrayIsBoundary -Bytes $Lines[$i] -Boundary $MetaData.Boundary.End -Encoding $Encoding)) {
$boundaryIndexes += $i
}
}
# loop through the boundary indexes (exclude last, as it's the end boundary)
for ($i = 0; $i -lt ($boundaryIndexes.Length - 1); $i++)
{
$bIndex = $boundaryIndexes[$i]
# the next line contains the key-value field names (content-disposition)
$fields = @{}
$disp = ConvertFrom-PodeBytesToString -Bytes $Lines[$bIndex+1] -Encoding $Encoding -RemoveNewLine
foreach ($line in @($disp -isplit ';')) {
$atoms = @($line -isplit '=')
if ($atoms.Length -eq 2) {
$fields[$atoms[0].Trim()] = $atoms[1].Trim(' "')
}
}
# use the next line to work out field values
if (!$fields.ContainsKey('filename')) {
$value = ConvertFrom-PodeBytesToString -Bytes $Lines[$bIndex+3] -Encoding $Encoding -RemoveNewLine
$Result.Data.Add($fields.name, $value)
}
# if we have a file, work out file and content type
if ($fields.ContainsKey('filename')) {
$Result.Data.Add($fields.name, $fields.filename)
if (![string]::IsNullOrWhiteSpace($fields.filename)) {
$type = ConvertFrom-PodeBytesToString -Bytes $Lines[$bIndex+2] -Encoding $Encoding -RemoveNewLine
$Result.Files.Add($fields.filename, @{
ContentType = @($type -isplit ':')[1].Trim()
Bytes = $null
})
$bytes = @()
foreach ($b in ($Lines[($bIndex+4)..($boundaryIndexes[$i+1]-1)])) {
$bytes += $b
}
$Result.Files[$fields.filename].Bytes = (Remove-PodeNewLineBytesFromArray $bytes $Encoding)
}
}
}
}
default {
$Result.Data = $Content
}
}
$Content = $null
return $Result
}
function Get-PodeContentTypeAndBoundary
{
param (
[Parameter()]
[string]
$ContentType
)
$obj = @{
ContentType = [string]::Empty;
Boundary = @{
Start = [string]::Empty;
End = [string]::Empty;
}
}
if ([string]::IsNullOrWhiteSpace($ContentType)) {
return $obj
}
$split = @($ContentType -isplit ';')
$obj.ContentType = $split[0].Trim()
if ($split.Length -gt 1) {
$obj.Boundary.Start = "--$(($split[1] -isplit '=')[1].Trim())"
$obj.Boundary.End = "$($obj.Boundary.Start)--"
}
return $obj
}
function ConvertFrom-PodeNameValueToHashTable
{
param (
[Parameter()]
[System.Collections.Specialized.NameValueCollection]
$Collection
)
if ((Get-PodeCount -Object $Collection) -eq 0) {
return @{}
}
$ht = @{}
foreach ($key in $Collection.Keys) {
$ht[$key] = $Collection[$key]
}
return $ht
}
function Get-PodeCount
{
param (
[Parameter()]
$Object
)
if ($null -eq $Object) {
return 0
}
if ($Object -is [string]){
return $Object.Length
}
if ($Object -is [System.Collections.Specialized.NameValueCollection]) {
if ($Object.Count -eq 0) {
return 0
}
if (($Object.Count -eq 1) -and ($null -eq $Object.Keys[0])) {
return 0
}
}
return $Object.Count
}
function Test-PodePathAccess
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Path
)
try {
Get-Item $Path | Out-Null
}
catch [System.UnauthorizedAccessException] {
return $false
}
return $true
}
function Test-PodePath
{
param (
[Parameter()]
$Path,
[switch]
$NoStatus,
[switch]
$FailOnDirectory
)
# if the file doesnt exist then fail on 404
if ([string]::IsNullOrWhiteSpace($Path) -or !(Test-Path $Path)) {
if (!$NoStatus) {
Set-PodeResponseStatus -Code 404
}
return $false
}
# if the file isn't accessible then fail 401
if (!(Test-PodePathAccess $Path)) {
if (!$NoStatus) {
Set-PodeResponseStatus -Code 401
}
return $false
}
# if we're failing on a directory then fail on 404
if ($FailOnDirectory -and (Test-PodePathIsDirectory $Path)) {
if (!$NoStatus) {
Set-PodeResponseStatus -Code 404
}
return $false
}
return $true
}
function Test-PodePathIsFile
{
param (
[Parameter()]
[string]
$Path,
[switch]
$FailOnWildcard
)
if ([string]::IsNullOrWhiteSpace($Path)) {
return $false
}
if ($FailOnWildcard -and (Test-PodePathIsWildcard $Path)) {
return $false
}
return (![string]::IsNullOrWhiteSpace([System.IO.Path]::GetExtension($Path)))
}
function Test-PodePathIsWildcard
{
param (
[Parameter()]
[string]
$Path
)
if ([string]::IsNullOrWhiteSpace($Path)) {
return $false
}
return $Path.Contains('*')
}
function Test-PodePathIsDirectory
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Path,
[switch]
$FailOnWildcard
)
if ($FailOnWildcard -and (Test-PodePathIsWildcard $Path)) {
return $false
}
return ([string]::IsNullOrWhiteSpace([System.IO.Path]::GetExtension($Path)))
}
function Convert-PodePathSeparators
{
param (
[Parameter()]
$Paths
)
return @($Paths | ForEach-Object {
if (![string]::IsNullOrWhiteSpace($_)) {
$_ -ireplace '[\\/]', [System.IO.Path]::DirectorySeparatorChar
}
})
}
function Convert-PodePathPatternToRegex
{
param (
[Parameter()]
[string]
$Path,
[switch]
$NotSlashes,
[switch]
$NotStrict
)
if (!$NotSlashes) {
if ($Path -match '[\\/]\*$') {
$Path = $Path -replace '[\\/]\*$', '/{0,1}*'
}
$Path = $Path -ireplace '[\\/]', '[\\/]'
}
$Path = $Path -ireplace '\.', '\.'
$Path = $Path -ireplace '\*', '.*?'
if ($NotStrict) {
return $Path
}
return "^$($Path)$"
}
function Convert-PodePathPatternsToRegex
{
param (
[Parameter()]
[string[]]
$Paths,
[switch]
$NotSlashes,
[switch]
$NotStrict
)
# remove any empty entries
$Paths = @($Paths | Where-Object {
!(Test-PodeIsEmpty $_)
})
# if no paths, return null
if (Test-PodeIsEmpty $Paths) {
return $null
}
# replace certain chars
$Paths = @($Paths | ForEach-Object {
if (!(Test-PodeIsEmpty $_)) {
Convert-PodePathPatternToRegex -Path $_ -NotStrict -NotSlashes:$NotSlashes
}
})
# join them all together
$joined = "($($Paths -join '|'))"
if ($NotStrict) {
return "$($joined)"
}
return "^$($joined)$"
}
function ConvertTo-PodeSslProtocols
{
param(
[Parameter()]
[ValidateSet('Ssl2', 'Ssl3', 'Tls', 'Tls11', 'Tls12', 'Tls13')]
[string[]]
$Protocols
)
$protos = 0
foreach ($protocol in $Protocols) {
$protos = [int]($protos -bor [System.Security.Authentication.SslProtocols]::$protocol)
}
return [System.Security.Authentication.SslProtocols]($protos)
}
function Get-PodeModulePath
{
# if there's 1 module imported already, use that
$importedModule = @(Get-Module -Name Pode)
if (($importedModule | Measure-Object).Count -eq 1) {
return (@($importedModule)[0]).Path
}
# if there's none or more, attempt to get the module used for 'engine'
try {
$usedModule = (Get-Command -Name 'Set-PodeViewEngine').Module
if (($usedModule | Measure-Object).Count -eq 1) {
return $usedModule.Path
}
}
catch { }
# if there were multiple to begin with, use the newest version
if (($importedModule | Measure-Object).Count -gt 1) {
return (@($importedModule | Sort-Object -Property Version)[-1]).Path
}
# otherwise there were none, use the latest installed
return (@(Get-Module -ListAvailable -Name Pode | Sort-Object -Property Version)[-1]).Path
}
function Get-PodeModuleRootPath
{
return (Split-Path -Parent -Path $PodeContext.Server.PodeModulePath)
}
function Get-PodeModuleMiscPath
{
return (Join-Path (Get-PodeModuleRootPath) 'Misc')
}
function Get-PodeUrl
{
return "$($WebEvent.Endpoint.Protocol)://$($WebEvent.Endpoint.Address)$($WebEvent.Path)"
}
function Find-PodeErrorPage
{
param (
[Parameter()]
[int]
$Code,
[Parameter()]
[string]
$ContentType
)
# if a defined content type is supplied, attempt to find an error page for that first
if (![string]::IsNullOrWhiteSpace($ContentType)) {
$path = Get-PodeErrorPage -Code $Code -ContentType $ContentType
if (![string]::IsNullOrWhiteSpace($path)) {
return @{ 'Path' = $path; 'ContentType' = $ContentType }
}
}
# if a defined route error page content type is supplied, attempt to find an error page for that
if (![string]::IsNullOrWhiteSpace($WebEvent.ErrorType)) {
$path = Get-PodeErrorPage -Code $Code -ContentType $WebEvent.ErrorType
if (![string]::IsNullOrWhiteSpace($path)) {
return @{ 'Path' = $path; 'ContentType' = $WebEvent.ErrorType }
}
}
# if route patterns have been defined, see if an error content type matches and attempt that
if (!(Test-PodeIsEmpty $PodeContext.Server.Web.ErrorPages.Routes)) {
# find type by pattern
$matched = @(foreach ($key in $PodeContext.Server.Web.ErrorPages.Routes.Keys) {
if ($WebEvent.Path -imatch $key) {
$key
}
})[0]
# if we have a match, see if a page exists
if (!(Test-PodeIsEmpty $matched)) {
$type = $PodeContext.Server.Web.ErrorPages.Routes[$matched]
$path = Get-PodeErrorPage -Code $Code -ContentType $type
if (![string]::IsNullOrWhiteSpace($path)) {
return @{ 'Path' = $path; 'ContentType' = $type }
}
}
}
# if we're using strict typing, attempt that, if we have a content type
if ($PodeContext.Server.Web.ErrorPages.StrictContentTyping -and ![string]::IsNullOrWhiteSpace($WebEvent.ContentType)) {
$path = Get-PodeErrorPage -Code $Code -ContentType $WebEvent.ContentType
if (![string]::IsNullOrWhiteSpace($path)) {
return @{ 'Path' = $path; 'ContentType' = $WebEvent.ContentType }
}
}
# if we have a default defined, attempt that
if (!(Test-PodeIsEmpty $PodeContext.Server.Web.ErrorPages.Default)) {
$path = Get-PodeErrorPage -Code $Code -ContentType $PodeContext.Server.Web.ErrorPages.Default
if (![string]::IsNullOrWhiteSpace($path)) {
return @{ 'Path' = $path; 'ContentType' = $PodeContext.Server.Web.ErrorPages.Default }
}
}
# if there's still no error page, use default HTML logic
$type = Get-PodeContentType -Extension 'html'
$path = (Get-PodeErrorPage -Code $Code -ContentType $type)
if (![string]::IsNullOrWhiteSpace($path)) {
return @{ 'Path' = $path; 'ContentType' = $type }
}
return $null
}
function Get-PodeErrorPage
{
param (
[Parameter()]
[int]
$Code,
[Parameter()]
[string]
$ContentType
)
# parse the passed content type
$ContentType = (Get-PodeContentTypeAndBoundary -ContentType $ContentType).ContentType
# object for the page path
$path = $null
# attempt to find a custom error page
$path = Find-PodeCustomErrorPage -Code $Code -ContentType $ContentType
# if there's no custom page found, attempt to find an inbuilt page
if ([string]::IsNullOrWhiteSpace($path)) {
$podeRoot = Get-PodeModuleMiscPath
$path = Find-PodeFileForContentType -Path $podeRoot -Name 'default-error-page' -ContentType $ContentType -Engine 'pode'
}
# if there's no path found, or it's inaccessible, return null
if (!(Test-PodePath $path -NoStatus)) {
return $null
}
return $path
}
function Find-PodeCustomErrorPage
{
param (
[Parameter()]
[int]
$Code,
[Parameter()]
[string]
$ContentType
)
# get the custom errors path
$customErrPath = $PodeContext.Server.InbuiltDrives['errors']
# if there's no custom error path, return
if ([string]::IsNullOrWhiteSpace($customErrPath)) {
return $null
}
# retrieve a status code page
$path = (Find-PodeFileForContentType -Path $customErrPath -Name "$($Code)" -ContentType $ContentType)
if (![string]::IsNullOrWhiteSpace($path)) {
return $path
}
# retrieve default page
$path = (Find-PodeFileForContentType -Path $customErrPath -Name 'default' -ContentType $ContentType)
if (![string]::IsNullOrWhiteSpace($path)) {
return $path
}
# no file was found
return $null
}
function Find-PodeFileForContentType
{
param (
[Parameter()]
[string]
$Path,
[Parameter()]
[string]
$Name,
[Parameter()]
[string]
$ContentType,
[Parameter()]
[string]
$Engine = $null
)
# get all files at the path that start with the name
$files = @(Get-ChildItem -Path (Join-Path $Path "$($Name).*"))
# if there are no files, return
if ($null -eq $files -or $files.Length -eq 0) {
return $null
}
# filter the files by the view engine extension (but only if the current engine is dynamic - non-html)
if ([string]::IsNullOrWhiteSpace($Engine) -and $PodeContext.Server.ViewEngine.IsDynamic) {
$Engine = $PodeContext.Server.ViewEngine.Extension
}
$Engine = (Protect-PodeValue -Value $Engine -Default 'pode')
if ($Engine -ine 'pode') {
$Engine = "($($Engine)|pode)"
}
$engineFiles = @(foreach ($file in $files) {
if ($file.Name -imatch "\.$($Engine)$") {
$file
}
})
$files = @(foreach ($file in $files) {
if ($file.Name -inotmatch "\.$($Engine)$") {
$file
}
})
# only attempt static files if we still have files after any engine filtering
if ($null -ne $files -and $files.Length -gt 0)
{
# get files of the format '<name>.<type>'
$file = @(foreach ($f in $files) {
if ($f.Name -imatch "^$($Name)\.(?<ext>.*?)$") {
if (($ContentType -ieq (Get-PodeContentType -Extension $Matches['ext']))) {
$f.FullName
}
}
})[0]
if (![string]::IsNullOrWhiteSpace($file)) {
return $file
}
}
# only attempt these formats if we have a files for the view engine
if ($null -ne $engineFiles -and $engineFiles.Length -gt 0)
{
# get files of the format '<name>.<type>.<engine>'
$file = @(foreach ($f in $engineFiles) {
if ($f.Name -imatch "^$($Name)\.(?<ext>.*?)\.$($engine)$") {
if ($ContentType -ieq (Get-PodeContentType -Extension $Matches['ext'])) {
$f.FullName
}
}
})[0]
if (![string]::IsNullOrWhiteSpace($file)) {
return $file
}
# get files of the format '<name>.<engine>'
$file = @(foreach ($f in $engineFiles) {
if ($f.Name -imatch "^$($Name)\.$($engine)$") {
$f.FullName
}
})[0]
if (![string]::IsNullOrWhiteSpace($file)) {
return $file
}
}
# no file was found
return $null
}
function Test-PodePathIsRelative
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path
)
if (@('.', '..') -contains $Path) {
return $true
}
return ($Path -match '^\.{1,2}[\\/]')
}
function Get-PodeRelativePath
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[string]
$RootPath,
[switch]
$JoinRoot,
[switch]
$Resolve,
[switch]
$TestPath
)
# if the path is relative, join to root if flagged
if ($JoinRoot -and (Test-PodePathIsRelative -Path $Path)) {
if ([string]::IsNullOrWhiteSpace($RootPath)) {
$RootPath = $PodeContext.Server.Root
}
$Path = Join-Path $RootPath $Path
}
# if flagged, resolve the path
if ($Resolve) {
$_rawPath = $Path
$Path = (Resolve-Path -Path $Path -ErrorAction Ignore).Path
}
# if flagged, test the path and throw error if it doesn't exist
if ($TestPath -and !(Test-PodePath $Path -NoStatus)) {
throw "The path does not exist: $(Protect-PodeValue -Value $Path -Default $_rawPath)"
}
return $Path
}
function Get-PodeWildcardFiles
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[string]
$Wildcard = '*.*',
[Parameter()]
[string]
$RootPath
)
# if the OriginalPath is a directory, add wildcard
if (Test-PodePathIsDirectory -Path $Path) {
$Path = (Join-Path $Path $Wildcard)
}
# if path has a *, assume wildcard
if (Test-PodePathIsWildcard -Path $Path) {
$Path = Get-PodeRelativePath -Path $Path -RootPath $RootPath -JoinRoot
return @((Get-ChildItem $Path -Recurse -Force).FullName)
}
return $null
}
function Test-PodeIsServerless
{
param (
[Parameter()]
[string]
$FunctionName,
[switch]
$ThrowError
)
if ($PodeContext.Server.IsServerless -and $ThrowError) {
throw "The $($FunctionName) function is not supported in a serverless context"
}
if (!$ThrowError) {
return $PodeContext.Server.IsServerless
}
}
function Get-PodeEndpointUrl
{
param (
[Parameter()]
$Endpoint
)
# get the endpoint on which we're currently listening - use first http/https if there are many
if ($null -eq $Endpoint) {
$Endpoint = @($PodeContext.Server.Endpoints.Values | Where-Object { $_.Protocol -iin @('http', 'https') -and $_.Default })[0]
if ($null -eq $Endpoint) {
$Endpoint = @($PodeContext.Server.Endpoints.Values | Where-Object { $_.Protocol -iin @('http', 'https') })[0]
}
}
$url = $Endpoint.Url
if ([string]::IsNullOrWhiteSpace($url)) {
$url = "$($Endpoint.Protocol)://$($Endpoint.FriendlyName):$($Endpoint.Port)"
}
return $url
}
function Get-PodeDefaultPort
{
param(
[Parameter()]
[ValidateSet('Http', 'Https', 'Smtp', 'Tcp', 'Ws', 'Wss')]
[string]
$Protocol,
[switch]
$Real
)
# are we after the real default ports?
if ($Real) {
return (@{
Http = 80
Https = 443
Smtp = 25
Tcp = 9001
Ws = 80
Wss = 443
})[$Protocol.ToLowerInvariant()]
}
# if we running as iis, return the ASPNET port
if ($PodeContext.Server.IsIIS) {
return [int]$env:ASPNETCORE_PORT
}
# if we running as heroku, return the port
if ($PodeContext.Server.IsHeroku) {
return [int]$env:PORT
}
# otherwise, get the port for the protocol
return (@{
Http = 8080
Https = 8443
Smtp = 25
Tcp = 9001
Ws = 9080
Wss = 9443
})[$Protocol.ToLowerInvariant()]
}
function Set-PodeServerHeader
{
param (
[Parameter()]
[string]
$Type,
[switch]
$AllowEmptyType
)
$name = 'Pode'
if (![string]::IsNullOrWhiteSpace($Type) -or $AllowEmptyType) {
$name += " - $($Type)"
}
Set-PodeHeader -Name 'Server' -Value $name
}
function Get-PodeHandler
{
param (
[Parameter(Mandatory=$true)]
[ValidateSet('Service', 'Smtp', 'Tcp')]
[string]
$Type,
[Parameter()]
[string]
$Name
)
if ([string]::IsNullOrWhiteSpace($Name)) {
return $PodeContext.Server.Handlers[$Type]
}
return $PodeContext.Server.Handlers[$Type][$Name]
}
function Convert-PodeFileToScriptBlock
{
param(
[Parameter(Mandatory=$true)]
[string]
$FilePath
)
# resolve for relative path
$FilePath = Get-PodeRelativePath -Path $FilePath -JoinRoot
# if file doesn't exist, error
if (!(Test-PodePath -Path $FilePath -NoStatus)) {
throw "The FilePath supplied does not exist: $($FilePath)"
}
# if the path is a wildcard or directory, error
if (!(Test-PodePathIsFile -Path $FilePath -FailOnWildcard)) {
throw "The FilePath supplied cannot be a wildcard or a directory: $($FilePath)"
}
return ([scriptblock](Use-PodeScript -Path $FilePath))
}
function Convert-PodeQueryStringToHashTable
{
param(
[Parameter()]
[string]
$Uri
)
if ([string]::IsNullOrWhiteSpace($Uri)) {
return @{}
}
$qmIndex = $Uri.IndexOf('?')
if ($qmIndex -eq -1) {
return @{}
}
if ($qmIndex -gt 0) {
$Uri = $Uri.Substring($qmIndex)
}
$tmpQuery = [System.Web.HttpUtility]::ParseQueryString($Uri)
return (ConvertFrom-PodeNameValueToHashTable -Collection $tmpQuery)
}
function Invoke-PodeUsingScriptConversion
{
param(
[Parameter()]
[scriptblock]
$ScriptBlock,
[Parameter(Mandatory=$true)]
[System.Management.Automation.SessionState]
$PSSession
)
# do nothing if no script
if ($null -eq $ScriptBlock) {
return @($ScriptBlock, $null)
}
# rename any __using_ vars for inner timers, etcs
$scriptStr = "$($ScriptBlock)"
$foundInnerUsing = $false
while ($scriptStr -imatch '(?<full>\$__using_(?<name>[a-z0-9_\?]+))') {
$foundInnerUsing = $true
$scriptStr = $scriptStr.Replace($Matches['full'], "`$using:$($Matches['name'])")
}
if ($foundInnerUsing) {
$ScriptBlock = [scriptblock]::Create($scriptStr)
}
# get any using variables
$usingVars = Get-PodeScriptUsingVariables -ScriptBlock $ScriptBlock
if (Test-PodeIsEmpty $usingVars) {
return @($ScriptBlock, $null)
}
# convert any using vars to use new names
$usingVars = ConvertTo-PodeUsingVariables -UsingVariables $usingVars -PSSession $PSSession
# now convert the script
$newScriptBlock = ConvertTo-PodeUsingScript -ScriptBlock $ScriptBlock -UsingVariables $usingVars
# return converted script
return @($newScriptBlock, $usingVars)
}
function Get-PodeScriptUsingVariables
{
param(
[Parameter(Mandatory=$true)]
[scriptblock]
$ScriptBlock
)
return $ScriptBlock.Ast.FindAll({ $args[0] -is [System.Management.Automation.Language.UsingExpressionAst] }, $true)
}
function ConvertTo-PodeUsingVariables
{
param(
[Parameter()]
$UsingVariables,
[Parameter(Mandatory=$true)]
[System.Management.Automation.SessionState]
$PSSession
)
if (Test-PodeIsEmpty $UsingVariables) {
return $null
}
$mapped = @{}
foreach ($usingVar in $UsingVariables) {
# var name
$varName = $usingVar.SubExpression.VariablePath.UserPath
# only retrieve value if new var
if (!$mapped.ContainsKey($varName)) {
# get value, or get __using_ value for child scripts
$value = $PSSession.PSVariable.Get($varName)
if ([string]::IsNullOrEmpty($value)) {
$value = $PSSession.PSVariable.Get("__using_$($varName)")
}
if ([string]::IsNullOrEmpty($value)) {
throw "Value for `$using:$($varName) could not be found"
}
# add to mapped
$mapped[$varName] = @{
OldName = $usingVar.SubExpression.Extent.Text
NewName = "__using_$($varName)"
NewNameWithDollar = "`$__using_$($varName)"
SubExpressions = @()
Value = $value.Value
}
}
# add the vars sub-expression for replacing later
$mapped[$varName].SubExpressions += $usingVar.SubExpression
}
return @($mapped.Values)
}
function ConvertTo-PodeUsingScript
{
param(
[Parameter(Mandatory=$true)]
[scriptblock]
$ScriptBlock,
[Parameter()]
[hashtable[]]
$UsingVariables
)
# return original script if no using vars
if (Test-PodeIsEmpty $UsingVariables) {
return $ScriptBlock
}
$varsList = New-Object 'System.Collections.Generic.List`1[System.Management.Automation.Language.VariableExpressionAst]'
$newParams = New-Object System.Collections.ArrayList
foreach ($usingVar in $UsingVariables) {
foreach ($subExp in $usingVar.SubExpressions) {
$varsList.Add($subExp) | Out-Null
}
}
$newParams.AddRange(@($UsingVariables.NewNameWithDollar))
$newParams = ($newParams -join ', ')
$tupleParams = [tuple]::Create($varsList, $newParams)
$bindingFlags = [System.Reflection.BindingFlags]'Default, NonPublic, Instance'
$_varReplacerMethod = $ScriptBlock.Ast.GetType().GetMethod('GetWithInputHandlingForInvokeCommandImpl', $bindingFlags)
$convertedScriptBlockStr = $_varReplacerMethod.Invoke($ScriptBlock.Ast, @($tupleParams))
if (!$ScriptBlock.Ast.ParamBlock) {
$convertedScriptBlockStr = "param($($newParams))`n$($convertedScriptBlockStr)"
}
$convertedScriptBlock = [scriptblock]::Create($convertedScriptBlockStr)
if ($convertedScriptBlock.Ast.EndBlock[0].Statements.Extent.Text.StartsWith('$input |')) {
$convertedScriptBlockStr = ($convertedScriptBlockStr -ireplace '\$input \|')
$convertedScriptBlock = [scriptblock]::Create($convertedScriptBlockStr)
}
return $convertedScriptBlock
}
function Get-PodeDotSourcedFiles
{
param(
[Parameter(Mandatory=$true)]
[System.Management.Automation.Language.Ast]
$Ast,
[Parameter()]
[string]
$RootPath
)
# set default root path
if ([string]::IsNullOrWhiteSpace($RootPath)) {
$RootPath = $PodeContext.Server.Root
}
# get all dot-sourced files
$cmdTypes = @('dot', 'ampersand')
$files = ($Ast.FindAll({
($args[0] -is [System.Management.Automation.Language.CommandAst]) -and
($args[0].InvocationOperator -iin $cmdTypes) -and
($args[0].CommandElements.StaticType.Name -ieq 'string')
}, $false)).CommandElements.Value
$fileOrder = @()
# no files found
if (($null -eq $files) -or ($files.Length -eq 0)) {
return $fileOrder
}
# get any sub sourced files
foreach ($file in $files) {
$file = Get-PodeRelativePath -Path $file -RootPath $RootPath -JoinRoot
$fileOrder += $file
$ast = Get-PodeAstFromFile -FilePath $file
$result = Get-PodeDotSourcedFiles -Ast $ast -RootPath (Split-Path -Parent -Path $file)
if (($null -ne $result) -and ($result.Length -gt 0)) {
$fileOrder += $result
}
}
# return all found files
return $fileOrder
}
function Get-PodeAstFromFile
{
param(
[Parameter(Mandatory=$true)]
[string]
$FilePath
)
if (!(Test-Path $FilePath)) {
throw "Path to script file does not exist: $($FilePath)"
}
return [System.Management.Automation.Language.Parser]::ParseFile($FilePath, [ref]$null, [ref]$null)
}
function Get-PodeFunctionsFromFile
{
param(
[Parameter(Mandatory=$true)]
[string]
$FilePath
)
$ast = Get-PodeAstFromFile -FilePath $FilePath
return @(Get-PodeFunctionsFromAst -Ast $ast)
}
function Get-PodeFunctionsFromAst
{
param(
[Parameter(Mandatory=$true)]
[System.Management.Automation.Language.Ast]
$Ast
)
$funcs = @(($Ast.FindAll({ $args[0] -is [System.Management.Automation.Language.FunctionDefinitionAst] }, $false)))
return @(foreach ($func in $funcs) {
# skip null
if ($null -eq $func) {
continue
}
# skip pode funcs
if ($func.Name -ilike '*-Pode*') {
continue
}
# the found func
@{
Name = $func.Name
Definition = "$($func.Body)".Trim('{}')
}
})
}
function Get-PodeFunctionsFromScriptBlock
{
param(
[Parameter(Mandatory=$true)]
[scriptblock]
$ScriptBlock
)
# functions that have been found
$foundFuncs = @()
# get each function in the callstack
$callstack = Get-PSCallStack
if ($callstack.Count -gt 3) {
$callstack = ($callstack | Select-Object -Skip 4)
$bindingFlags = [System.Reflection.BindingFlags]'NonPublic, Instance, Static'
foreach ($call in $callstack)
{
$_funcContext = $call.GetType().GetProperty('FunctionContext', $bindingFlags).GetValue($call, $null)
$_scriptBlock = $_funcContext.GetType().GetField('_scriptBlock', $bindingFlags).GetValue($_funcContext)
$foundFuncs += @(Get-PodeFunctionsFromAst -Ast $_scriptBlock.Ast)
}
}
# get each function from the main script
$foundFuncs += @(Get-PodeFunctionsFromAst -Ast $ScriptBlock.Ast)
# return the found functions
return $foundFuncs
}
function Read-PodeWebExceptionDetails
{
param(
[Parameter(Mandatory=$true)]
[System.Management.Automation.ErrorRecord]
$ErrorRecord
)
switch ($ErrorRecord) {
{ $_.Exception -is [System.Net.WebException] } {
$stream = $_.Exception.Response.GetResponseStream()
$stream.Position = 0
$body = [System.IO.StreamReader]::new($stream).ReadToEnd()
$code = [int]$_.Exception.Response.StatusCode
$desc = $_.Exception.Response.StatusDescription
}
{ $_.Exception -is [System.Net.Http.HttpRequestException] } {
$body = $_.ErrorDetails.Message
$code = [int]$_.Exception.Response.StatusCode
$desc = $_.Exception.Response.ReasonPhrase
}
default {
throw "Exception is of an invalid type, should be either WebException or HttpRequestException, but got: $($_.Exception.GetType().Name)"
}
}
return @{
Status = @{
Code = $code
Description = $desc
}
Body = $body
}
}
function Get-PodeLoggingTerminalMethod
{
return {
param($item, $options)
if ($PodeContext.Server.Quiet) {
return
}
# check if it's an array from batching
if ($item -is [array]) {
$item = ($item -join [System.Environment]::NewLine)
}
# protect then write
$item = ($item | Protect-PodeLogItem)
$item.ToString() | Out-PodeHost
}
}
function Get-PodeLoggingFileMethod
{
return {
param($item, $options)
# check if it's an array from batching
if ($item -is [array]) {
$item = ($item -join [System.Environment]::NewLine)
}
# mask values
$item = ($item | Protect-PodeLogItem)
# variables
$date = [DateTime]::Now.ToString('yyyy-MM-dd')
# do we need to reset the fileId?
if ($options.Date -ine $date) {
$options.Date = $date
$options.FileId = 0
}
# get the fileId
if ($options.FileId -eq 0) {
$path = (Join-Path $options.Path "$($options.Name)_$($date)_*.log")
$options.FileId = (@(Get-ChildItem -Path $path)).Length
if ($options.FileId -eq 0) {
$options.FileId = 1
}
}
$id = "$($options.FileId)".PadLeft(3, '0')
if ($options.MaxSize -gt 0) {
$path = (Join-Path $options.Path "$($options.Name)_$($date)_$($id).log")
if ((Get-Item -Path $path -Force).Length -ge $options.MaxSize) {
$options.FileId++
$id = "$($options.FileId)".PadLeft(3, '0')
}
}
# get the file to write to
$path = (Join-Path $options.Path "$($options.Name)_$($date)_$($id).log")
# write the item to the file
$item.ToString() | Out-File -FilePath $path -Encoding utf8 -Append -Force
# if set, remove log files beyond days set (ensure this is only run once a day)
if (($options.MaxDays -gt 0) -and ($options.NextClearDown -lt [DateTime]::Now.Date)) {
$date = [DateTime]::Now.Date.AddDays(-$options.MaxDays)
Get-ChildItem -Path $options.Path -Filter '*.log' -Force |
Where-Object { $_.CreationTime -lt $date } |
Remove-Item $_ -Force | Out-Null
$options.NextClearDown = [DateTime]::Now.Date.AddDays(1)
}
}
}
function Get-PodeLoggingInbuiltType
{
param (
[Parameter(Mandatory=$true)]
[ValidateSet('Errors', 'Requests')]
[string]
$Type
)
switch ($Type.ToLowerInvariant())
{
'requests' {
$script = {
param($item, $options)
# just return the item if Raw is set
if ($options.Raw) {
return $item
}
function sg($value) {
if ([string]::IsNullOrWhiteSpace($value)) {
return '-'
}
return $value
}
# build the url with http method
$url = "$(sg $item.Request.Method) $(sg $item.Request.Resource) $(sg $item.Request.Protocol)"
# build and return the request row
return "$(sg $item.Host) $(sg $item.RfcUserIdentity) $(sg $item.User) [$(sg $item.Date)] `"$($url)`" $(sg $item.Response.StatusCode) $(sg $item.Response.Size) `"$(sg $item.Request.Referrer)`" `"$(sg $item.Request.Agent)`""
}
}
'errors' {
$script = {
param($item, $options)
# do nothing if the error level isn't present
if (@($options.Levels) -inotcontains $item.Level) {
return
}
# just return the item if Raw is set
if ($options.Raw) {
return $item
}
# build the exception details
$row = @(
"Date: $($item.Date.ToString('yyyy-MM-dd HH:mm:ss'))",
"Level: $($item.Level)",
"ThreadId: $($item.ThreadId)",
"Server: $($item.Server)",
"Category: $($item.Category)",
"Message: $($item.Message)",
"StackTrace: $($item.StackTrace)"
)
# join the details and return
return "$($row -join "`n")`n"
}
}
}
return $script
}
function Get-PodeRequestLoggingName
{
return '__pode_log_requests__'
}
function Get-PodeErrorLoggingName
{
return '__pode_log_errors__'
}
function Get-PodeLogger
{
param (
[Parameter(Mandatory=$true)]
[string]
$Name
)
return $PodeContext.Server.Logging.Types[$Name]
}
function Test-PodeLoggerEnabled
{
param (
[Parameter(Mandatory=$true)]
[string]
$Name
)
return ($PodeContext.Server.Logging.Enabled -and $PodeContext.Server.Logging.Types.ContainsKey($Name))
}
function Test-PodeErrorLoggingEnabled
{
return (Test-PodeLoggerEnabled -Name (Get-PodeErrorLoggingName))
}
function Test-PodeRequestLoggingEnabled
{
return (Test-PodeLoggerEnabled -Name (Get-PodeRequestLoggingName))
}
function Write-PodeRequestLog
{
param (
[Parameter(Mandatory=$true)]
$Request,
[Parameter(Mandatory=$true)]
$Response,
[Parameter()]
[string]
$Path
)
# do nothing if logging is disabled, or request logging isn't setup
$name = Get-PodeRequestLoggingName
if (!(Test-PodeLoggerEnabled -Name $name)) {
return
}
# build a request object
$item = @{
Host = $Request.RemoteEndPoint.Address.IPAddressToString
RfcUserIdentity = '-'
User = '-'
Date = [DateTime]::Now.ToString('dd/MMM/yyyy:HH:mm:ss zzz')
Request = @{
Method = $Request.HttpMethod.ToUpperInvariant()
Resource = $Path
Protocol = "HTTP/$($Request.ProtocolVersion)"
Referrer = $Request.UrlReferrer
Agent = $Request.UserAgent
}
Response = @{
StatusCode = $Response.StatusCode
StatusDescription = $Response.StatusDescription
Size = '-'
}
}
if ($Response.ContentLength64 -gt 0) {
$item.Response.Size = $Response.ContentLength64
}
# add the item to be processed
$PodeContext.LogsToProcess.Add(@{
Name = $name
Item = $item
}) | Out-Null
}
function Add-PodeRequestLogEndware
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$WebEvent
)
# do nothing if logging is disabled, or request logging isn't setup
$name = Get-PodeRequestLoggingName
if (!(Test-PodeLoggerEnabled -Name $name)) {
return
}
# add the request logging endware
$WebEvent.OnEnd += @{
Logic = {
Write-PodeRequestLog -Request $WebEvent.Request -Response $WebEvent.Response -Path $WebEvent.Path
}
}
}
function Start-PodeLoggingRunspace
{
# skip if there are no loggers configured, or logging is disabled
if (($PodeContext.Server.Logging.Types.Count -eq 0) -or (!$PodeContext.Server.Logging.Enabled)) {
return
}
$script = {
while ($true)
{
# if there are no logs to process, just sleep for a few seconds - but after checking the batch
if ($PodeContext.LogsToProcess.Count -eq 0) {
Test-PodeLoggerBatches
Start-Sleep -Seconds 5
continue
}
# safely pop off the first log from the array
$log = (Lock-PodeObject -Return -Object $PodeContext.LogsToProcess -ScriptBlock {
$log = $PodeContext.LogsToProcess[0]
$PodeContext.LogsToProcess.RemoveAt(0) | Out-Null
return $log
})
# run the log item through the appropriate method
$logger = Get-PodeLogger -Name $log.Name
$now = [datetime]::Now
# if the log is null, check batch then sleep and skip
if ($null -eq $log) {
Start-Sleep -Milliseconds 100
continue
}
# convert to log item into a writable format
$_args = @($log.Item) + @($logger.Arguments)
if ($null -ne $logger.UsingVariables) {
$_vars = @()
foreach ($_var in $logger.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
$result = @(Invoke-PodeScriptBlock -ScriptBlock $logger.ScriptBlock -Arguments $_args -Return -Splat)
# check batching
$batch = $logger.Method.Batch
if ($batch.Size -gt 1) {
# add current item to batch
$batch.Items += $result
$batch.LastUpdate = $now
# if the current amount of items matches the batch, write
$result = $null
if ($batch.Items.Length -ge $batch.Size) {
$result = $batch.Items
}
# if we're writing, reset the items
if ($null -ne $result) {
$batch.Items = @()
}
}
# send the writable log item off to the log writer
if ($null -ne $result) {
$_args = @(,$result) + @($logger.Method.Arguments)
if ($null -ne $logger.Method.UsingVariables) {
$_vars = @()
foreach ($_var in $logger.Method.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
Invoke-PodeScriptBlock -ScriptBlock $logger.Method.ScriptBlock -Arguments $_args -Splat
}
# small sleep to lower cpu usage
Start-Sleep -Milliseconds 100
}
}
Add-PodeRunspace -Type Main -ScriptBlock $script
}
function Test-PodeLoggerBatches
{
$now = [datetime]::Now
# check each logger, and see if its batch needs to be written
foreach ($logger in $PodeContext.Server.Logging.Types.Values)
{
$batch = $logger.Method.Batch
if (($batch.Size -gt 1) -and ($batch.Items.Length -gt 0) -and
($batch.Timeout -gt 0) -and ($null -ne $batch.LastUpdate) -and ($batch.LastUpdate.AddSeconds($batch.Timeout) -le $now))
{
$result = $batch.Items
$batch.Items = @()
$_args = @(,$result) + @($logger.Method.Arguments)
if ($null -ne $logger.Method.UsingVariables) {
$_vars = @()
foreach ($_var in $logger.Method.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
Invoke-PodeScriptBlock -ScriptBlock $logger.Method.ScriptBlock -Arguments $_args -Splat
}
}
}
function Get-PodeContentType
{
param (
[Parameter()]
[string]
$Extension,
[switch]
$DefaultIsNull
)
if ([string]::IsNullOrWhiteSpace($Extension)) {
$Extension = [string]::Empty
}
if (!$Extension.StartsWith('.')) {
$Extension = ".$($Extension)"
}
# Sourced from https://github.com/samuelneff/MimeTypeMap
switch ($Extension.ToLowerInvariant())
{
'.323' { return 'text/h323' }
'.3g2' { return 'video/3gpp2' }
'.3gp' { return 'video/3gpp' }
'.3gp2' { return 'video/3gpp2' }
'.3gpp' { return 'video/3gpp' }
'.7z' { return 'application/x-7z-compressed' }
'.aa' { return 'audio/audible' }
'.aac' { return 'audio/aac' }
'.aaf' { return 'application/octet-stream' }
'.aax' { return 'audio/vnd.audible.aax' }
'.ac3' { return 'audio/ac3' }
'.aca' { return 'application/octet-stream' }
'.accda' { return 'application/msaccess.addin' }
'.accdb' { return 'application/msaccess' }
'.accdc' { return 'application/msaccess.cab' }
'.accde' { return 'application/msaccess' }
'.accdr' { return 'application/msaccess.runtime' }
'.accdt' { return 'application/msaccess' }
'.accdw' { return 'application/msaccess.webapplication' }
'.accft' { return 'application/msaccess.ftemplate' }
'.acx' { return 'application/internet-property-stream' }
'.addin' { return 'text/xml' }
'.ade' { return 'application/msaccess' }
'.adobebridge' { return 'application/x-bridge-url' }
'.adp' { return 'application/msaccess' }
'.adt' { return 'audio/vnd.dlna.adts' }
'.adts' { return 'audio/aac' }
'.afm' { return 'application/octet-stream' }
'.ai' { return 'application/postscript' }
'.aif' { return 'audio/aiff' }
'.aifc' { return 'audio/aiff' }
'.aiff' { return 'audio/aiff' }
'.air' { return 'application/vnd.adobe.air-application-installer-package+zip' }
'.amc' { return 'application/mpeg' }
'.anx' { return 'application/annodex' }
'.apk' { return 'application/vnd.android.package-archive' }
'.application' { return 'application/x-ms-application' }
'.art' { return 'image/x-jg' }
'.asa' { return 'application/xml' }
'.asax' { return 'application/xml' }
'.ascx' { return 'application/xml' }
'.asd' { return 'application/octet-stream' }
'.asf' { return 'video/x-ms-asf' }
'.ashx' { return 'application/xml' }
'.asi' { return 'application/octet-stream' }
'.asm' { return 'text/plain' }
'.asmx' { return 'application/xml' }
'.aspx' { return 'application/xml' }
'.asr' { return 'video/x-ms-asf' }
'.asx' { return 'video/x-ms-asf' }
'.atom' { return 'application/atom+xml' }
'.au' { return 'audio/basic' }
'.avi' { return 'video/x-msvideo' }
'.axa' { return 'audio/annodex' }
'.axs' { return 'application/olescript' }
'.axv' { return 'video/annodex' }
'.bas' { return 'text/plain' }
'.bcpio' { return 'application/x-bcpio' }
'.bin' { return 'application/octet-stream' }
'.bmp' { return 'image/bmp' }
'.c' { return 'text/plain' }
'.cab' { return 'application/octet-stream' }
'.caf' { return 'audio/x-caf' }
'.calx' { return 'application/vnd.ms-office.calx' }
'.cat' { return 'application/vnd.ms-pki.seccat' }
'.cc' { return 'text/plain' }
'.cd' { return 'text/plain' }
'.cdda' { return 'audio/aiff' }
'.cdf' { return 'application/x-cdf' }
'.cer' { return 'application/x-x509-ca-cert' }
'.cfg' { return 'text/plain' }
'.chm' { return 'application/octet-stream' }
'.class' { return 'application/x-java-applet' }
'.clp' { return 'application/x-msclip' }
'.cmd' { return 'text/plain' }
'.cmx' { return 'image/x-cmx' }
'.cnf' { return 'text/plain' }
'.cod' { return 'image/cis-cod' }
'.config' { return 'application/xml' }
'.contact' { return 'text/x-ms-contact' }
'.coverage' { return 'application/xml' }
'.cpio' { return 'application/x-cpio' }
'.cpp' { return 'text/plain' }
'.crd' { return 'application/x-mscardfile' }
'.crl' { return 'application/pkix-crl' }
'.crt' { return 'application/x-x509-ca-cert' }
'.cs' { return 'text/plain' }
'.csdproj' { return 'text/plain' }
'.csh' { return 'application/x-csh' }
'.csproj' { return 'text/plain' }
'.css' { return 'text/css' }
'.csv' { return 'text/csv' }
'.cur' { return 'application/octet-stream' }
'.cxx' { return 'text/plain' }
'.dat' { return 'application/octet-stream' }
'.datasource' { return 'application/xml' }
'.dbproj' { return 'text/plain' }
'.dcr' { return 'application/x-director' }
'.def' { return 'text/plain' }
'.deploy' { return 'application/octet-stream' }
'.der' { return 'application/x-x509-ca-cert' }
'.dgml' { return 'application/xml' }
'.dib' { return 'image/bmp' }
'.dif' { return 'video/x-dv' }
'.dir' { return 'application/x-director' }
'.disco' { return 'text/xml' }
'.divx' { return 'video/divx' }
'.dll' { return 'application/x-msdownload' }
'.dll.config' { return 'text/xml' }
'.dlm' { return 'text/dlm' }
'.doc' { return 'application/msword' }
'.docm' { return 'application/vnd.ms-word.document.macroEnabled.12' }
'.docx' { return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' }
'.dot' { return 'application/msword' }
'.dotm' { return 'application/vnd.ms-word.template.macroEnabled.12' }
'.dotx' { return 'application/vnd.openxmlformats-officedocument.wordprocessingml.template' }
'.dsp' { return 'application/octet-stream' }
'.dsw' { return 'text/plain' }
'.dtd' { return 'text/xml' }
'.dtsconfig' { return 'text/xml' }
'.dv' { return 'video/x-dv' }
'.dvi' { return 'application/x-dvi' }
'.dwf' { return 'drawing/x-dwf' }
'.dwg' { return 'application/acad' }
'.dwp' { return 'application/octet-stream' }
'.dxf' { return 'application/x-dxf' }
'.dxr' { return 'application/x-director' }
'.eml' { return 'message/rfc822' }
'.emz' { return 'application/octet-stream' }
'.eot' { return 'application/vnd.ms-fontobject' }
'.eps' { return 'application/postscript' }
'.etl' { return 'application/etl' }
'.etx' { return 'text/x-setext' }
'.evy' { return 'application/envoy' }
'.exe' { return 'application/octet-stream' }
'.exe.config' { return 'text/xml' }
'.fdf' { return 'application/vnd.fdf' }
'.fif' { return 'application/fractals' }
'.filters' { return 'application/xml' }
'.fla' { return 'application/octet-stream' }
'.flac' { return 'audio/flac' }
'.flr' { return 'x-world/x-vrml' }
'.flv' { return 'video/x-flv' }
'.fsscript' { return 'application/fsharp-script' }
'.fsx' { return 'application/fsharp-script' }
'.generictest' { return 'application/xml' }
'.gif' { return 'image/gif' }
'.gpx' { return 'application/gpx+xml' }
'.group' { return 'text/x-ms-group' }
'.gsm' { return 'audio/x-gsm' }
'.gtar' { return 'application/x-gtar' }
'.gz' { return 'application/x-gzip' }
'.gzip' { return 'application/x-gzip' }
'.h' { return 'text/plain' }
'.hdf' { return 'application/x-hdf' }
'.hdml' { return 'text/x-hdml' }
'.hhc' { return 'application/x-oleobject' }
'.hhk' { return 'application/octet-stream' }
'.hhp' { return 'application/octet-stream' }
'.hlp' { return 'application/winhlp' }
'.hpp' { return 'text/plain' }
'.hqx' { return 'application/mac-binhex40' }
'.hta' { return 'application/hta' }
'.htc' { return 'text/x-component' }
'.htm' { return 'text/html' }
'.html' { return 'text/html' }
'.htt' { return 'text/webviewhtml' }
'.hxa' { return 'application/xml' }
'.hxc' { return 'application/xml' }
'.hxd' { return 'application/octet-stream' }
'.hxe' { return 'application/xml' }
'.hxf' { return 'application/xml' }
'.hxh' { return 'application/octet-stream' }
'.hxi' { return 'application/octet-stream' }
'.hxk' { return 'application/xml' }
'.hxq' { return 'application/octet-stream' }
'.hxr' { return 'application/octet-stream' }
'.hxs' { return 'application/octet-stream' }
'.hxt' { return 'text/html' }
'.hxv' { return 'application/xml' }
'.hxw' { return 'application/octet-stream' }
'.hxx' { return 'text/plain' }
'.i' { return 'text/plain' }
'.ico' { return 'image/x-icon' }
'.ics' { return 'application/octet-stream' }
'.idl' { return 'text/plain' }
'.ief' { return 'image/ief' }
'.iii' { return 'application/x-iphone' }
'.inc' { return 'text/plain' }
'.inf' { return 'application/octet-stream' }
'.ini' { return 'text/plain' }
'.inl' { return 'text/plain' }
'.ins' { return 'application/x-internet-signup' }
'.ipa' { return 'application/x-itunes-ipa' }
'.ipg' { return 'application/x-itunes-ipg' }
'.ipproj' { return 'text/plain' }
'.ipsw' { return 'application/x-itunes-ipsw' }
'.iqy' { return 'text/x-ms-iqy' }
'.isp' { return 'application/x-internet-signup' }
'.ite' { return 'application/x-itunes-ite' }
'.itlp' { return 'application/x-itunes-itlp' }
'.itms' { return 'application/x-itunes-itms' }
'.itpc' { return 'application/x-itunes-itpc' }
'.ivf' { return 'video/x-ivf' }
'.jar' { return 'application/java-archive' }
'.java' { return 'application/octet-stream' }
'.jck' { return 'application/liquidmotion' }
'.jcz' { return 'application/liquidmotion' }
'.jfif' { return 'image/pjpeg' }
'.jnlp' { return 'application/x-java-jnlp-file' }
'.jpb' { return 'application/octet-stream' }
'.jpe' { return 'image/jpeg' }
'.jpeg' { return 'image/jpeg' }
'.jpg' { return 'image/jpeg' }
'.js' { return 'application/javascript' }
'.json' { return 'application/json' }
'.jsx' { return 'text/jscript' }
'.jsxbin' { return 'text/plain' }
'.latex' { return 'application/x-latex' }
'.library-ms' { return 'application/windows-library+xml' }
'.lit' { return 'application/x-ms-reader' }
'.loadtest' { return 'application/xml' }
'.lpk' { return 'application/octet-stream' }
'.lsf' { return 'video/x-la-asf' }
'.lst' { return 'text/plain' }
'.lsx' { return 'video/x-la-asf' }
'.lzh' { return 'application/octet-stream' }
'.m13' { return 'application/x-msmediaview' }
'.m14' { return 'application/x-msmediaview' }
'.m1v' { return 'video/mpeg' }
'.m2t' { return 'video/vnd.dlna.mpeg-tts' }
'.m2ts' { return 'video/vnd.dlna.mpeg-tts' }
'.m2v' { return 'video/mpeg' }
'.m3u' { return 'audio/x-mpegurl' }
'.m3u8' { return 'audio/x-mpegurl' }
'.m4a' { return 'audio/m4a' }
'.m4b' { return 'audio/m4b' }
'.m4p' { return 'audio/m4p' }
'.m4r' { return 'audio/x-m4r' }
'.m4v' { return 'video/x-m4v' }
'.mac' { return 'image/x-macpaint' }
'.mak' { return 'text/plain' }
'.man' { return 'application/x-troff-man' }
'.manifest' { return 'application/x-ms-manifest' }
'.map' { return 'text/plain' }
'.markdown' { return 'text/markdown' }
'.master' { return 'application/xml' }
'.mbox' { return 'application/mbox' }
'.md' { return 'text/markdown' }
'.mda' { return 'application/msaccess' }
'.mdb' { return 'application/x-msaccess' }
'.mde' { return 'application/msaccess' }
'.mdp' { return 'application/octet-stream' }
'.me' { return 'application/x-troff-me' }
'.mfp' { return 'application/x-shockwave-flash' }
'.mht' { return 'message/rfc822' }
'.mhtml' { return 'message/rfc822' }
'.mid' { return 'audio/mid' }
'.midi' { return 'audio/mid' }
'.mix' { return 'application/octet-stream' }
'.mk' { return 'text/plain' }
'.mk3d' { return 'video/x-matroska-3d' }
'.mka' { return 'audio/x-matroska' }
'.mkv' { return 'video/x-matroska' }
'.mmf' { return 'application/x-smaf' }
'.mno' { return 'text/xml' }
'.mny' { return 'application/x-msmoney' }
'.mod' { return 'video/mpeg' }
'.mov' { return 'video/quicktime' }
'.movie' { return 'video/x-sgi-movie' }
'.mp2' { return 'video/mpeg' }
'.mp2v' { return 'video/mpeg' }
'.mp3' { return 'audio/mpeg' }
'.mp4' { return 'video/mp4' }
'.mp4v' { return 'video/mp4' }
'.mpa' { return 'video/mpeg' }
'.mpe' { return 'video/mpeg' }
'.mpeg' { return 'video/mpeg' }
'.mpf' { return 'application/vnd.ms-mediapackage' }
'.mpg' { return 'video/mpeg' }
'.mpp' { return 'application/vnd.ms-project' }
'.mpv2' { return 'video/mpeg' }
'.mqv' { return 'video/quicktime' }
'.ms' { return 'application/x-troff-ms' }
'.msg' { return 'application/vnd.ms-outlook' }
'.msi' { return 'application/octet-stream' }
'.mso' { return 'application/octet-stream' }
'.mts' { return 'video/vnd.dlna.mpeg-tts' }
'.mtx' { return 'application/xml' }
'.mvb' { return 'application/x-msmediaview' }
'.mvc' { return 'application/x-miva-compiled' }
'.mxp' { return 'application/x-mmxp' }
'.nc' { return 'application/x-netcdf' }
'.nsc' { return 'video/x-ms-asf' }
'.nws' { return 'message/rfc822' }
'.ocx' { return 'application/octet-stream' }
'.oda' { return 'application/oda' }
'.odb' { return 'application/vnd.oasis.opendocument.database' }
'.odc' { return 'application/vnd.oasis.opendocument.chart' }
'.odf' { return 'application/vnd.oasis.opendocument.formula' }
'.odg' { return 'application/vnd.oasis.opendocument.graphics' }
'.odh' { return 'text/plain' }
'.odi' { return 'application/vnd.oasis.opendocument.image' }
'.odl' { return 'text/plain' }
'.odm' { return 'application/vnd.oasis.opendocument.text-master' }
'.odp' { return 'application/vnd.oasis.opendocument.presentation' }
'.ods' { return 'application/vnd.oasis.opendocument.spreadsheet' }
'.odt' { return 'application/vnd.oasis.opendocument.text' }
'.oga' { return 'audio/ogg' }
'.ogg' { return 'audio/ogg' }
'.ogv' { return 'video/ogg' }
'.ogx' { return 'application/ogg' }
'.one' { return 'application/onenote' }
'.onea' { return 'application/onenote' }
'.onepkg' { return 'application/onenote' }
'.onetmp' { return 'application/onenote' }
'.onetoc' { return 'application/onenote' }
'.onetoc2' { return 'application/onenote' }
'.opus' { return 'audio/ogg' }
'.orderedtest' { return 'application/xml' }
'.osdx' { return 'application/opensearchdescription+xml' }
'.otf' { return 'application/font-sfnt' }
'.otg' { return 'application/vnd.oasis.opendocument.graphics-template' }
'.oth' { return 'application/vnd.oasis.opendocument.text-web' }
'.otp' { return 'application/vnd.oasis.opendocument.presentation-template' }
'.ots' { return 'application/vnd.oasis.opendocument.spreadsheet-template' }
'.ott' { return 'application/vnd.oasis.opendocument.text-template' }
'.oxt' { return 'application/vnd.openofficeorg.extension' }
'.p10' { return 'application/pkcs10' }
'.p12' { return 'application/x-pkcs12' }
'.p7b' { return 'application/x-pkcs7-certificates' }
'.p7c' { return 'application/pkcs7-mime' }
'.p7m' { return 'application/pkcs7-mime' }
'.p7r' { return 'application/x-pkcs7-certreqresp' }
'.p7s' { return 'application/pkcs7-signature' }
'.pbm' { return 'image/x-portable-bitmap' }
'.pcast' { return 'application/x-podcast' }
'.pct' { return 'image/pict' }
'.pcx' { return 'application/octet-stream' }
'.pcz' { return 'application/octet-stream' }
'.pdf' { return 'application/pdf' }
'.pfb' { return 'application/octet-stream' }
'.pfm' { return 'application/octet-stream' }
'.pfx' { return 'application/x-pkcs12' }
'.pgm' { return 'image/x-portable-graymap' }
'.pic' { return 'image/pict' }
'.pict' { return 'image/pict' }
'.pkgdef' { return 'text/plain' }
'.pkgundef' { return 'text/plain' }
'.pko' { return 'application/vnd.ms-pki.pko' }
'.pls' { return 'audio/scpls' }
'.pma' { return 'application/x-perfmon' }
'.pmc' { return 'application/x-perfmon' }
'.pml' { return 'application/x-perfmon' }
'.pmr' { return 'application/x-perfmon' }
'.pmw' { return 'application/x-perfmon' }
'.png' { return 'image/png' }
'.pnm' { return 'image/x-portable-anymap' }
'.pnt' { return 'image/x-macpaint' }
'.pntg' { return 'image/x-macpaint' }
'.pnz' { return 'image/png' }
'.pode' { return 'application/PowerShell' }
'.pot' { return 'application/vnd.ms-powerpoint' }
'.potm' { return 'application/vnd.ms-powerpoint.template.macroEnabled.12' }
'.potx' { return 'application/vnd.openxmlformats-officedocument.presentationml.template' }
'.ppa' { return 'application/vnd.ms-powerpoint' }
'.ppam' { return 'application/vnd.ms-powerpoint.addin.macroEnabled.12' }
'.ppm' { return 'image/x-portable-pixmap' }
'.pps' { return 'application/vnd.ms-powerpoint' }
'.ppsm' { return 'application/vnd.ms-powerpoint.slideshow.macroEnabled.12' }
'.ppsx' { return 'application/vnd.openxmlformats-officedocument.presentationml.slideshow' }
'.ppt' { return 'application/vnd.ms-powerpoint' }
'.pptm' { return 'application/vnd.ms-powerpoint.presentation.macroEnabled.12' }
'.pptx' { return 'application/vnd.openxmlformats-officedocument.presentationml.presentation' }
'.prf' { return 'application/pics-rules' }
'.prm' { return 'application/octet-stream' }
'.prx' { return 'application/octet-stream' }
'.ps' { return 'application/postscript' }
'.ps1' { return 'application/PowerShell' }
'.psc1' { return 'application/PowerShell' }
'.psd1' { return 'application/PowerShell' }
'.psm1' { return 'application/PowerShell' }
'.psd' { return 'application/octet-stream' }
'.psess' { return 'application/xml' }
'.psm' { return 'application/octet-stream' }
'.psp' { return 'application/octet-stream' }
'.pst' { return 'application/vnd.ms-outlook' }
'.pub' { return 'application/x-mspublisher' }
'.pwz' { return 'application/vnd.ms-powerpoint' }
'.qht' { return 'text/x-html-insertion' }
'.qhtm' { return 'text/x-html-insertion' }
'.qt' { return 'video/quicktime' }
'.qti' { return 'image/x-quicktime' }
'.qtif' { return 'image/x-quicktime' }
'.qtl' { return 'application/x-quicktimeplayer' }
'.qxd' { return 'application/octet-stream' }
'.ra' { return 'audio/x-pn-realaudio' }
'.ram' { return 'audio/x-pn-realaudio' }
'.rar' { return 'application/x-rar-compressed' }
'.ras' { return 'image/x-cmu-raster' }
'.rat' { return 'application/rat-file' }
'.rc' { return 'text/plain' }
'.rc2' { return 'text/plain' }
'.rct' { return 'text/plain' }
'.rdlc' { return 'application/xml' }
'.reg' { return 'text/plain' }
'.resx' { return 'application/xml' }
'.rf' { return 'image/vnd.rn-realflash' }
'.rgb' { return 'image/x-rgb' }
'.rgs' { return 'text/plain' }
'.rm' { return 'application/vnd.rn-realmedia' }
'.rmi' { return 'audio/mid' }
'.rmp' { return 'application/vnd.rn-rn_music_package' }
'.roff' { return 'application/x-troff' }
'.rpm' { return 'audio/x-pn-realaudio-plugin' }
'.rqy' { return 'text/x-ms-rqy' }
'.rtf' { return 'application/rtf' }
'.rtx' { return 'text/richtext' }
'.rvt' { return 'application/octet-stream' }
'.ruleset' { return 'application/xml' }
'.s' { return 'text/plain' }
'.safariextz' { return 'application/x-safari-safariextz' }
'.scd' { return 'application/x-msschedule' }
'.scr' { return 'text/plain' }
'.sct' { return 'text/scriptlet' }
'.sd2' { return 'audio/x-sd2' }
'.sdp' { return 'application/sdp' }
'.sea' { return 'application/octet-stream' }
'.searchconnector-ms' { return 'application/windows-search-connector+xml' }
'.setpay' { return 'application/set-payment-initiation' }
'.setreg' { return 'application/set-registration-initiation' }
'.settings' { return 'application/xml' }
'.sgimb' { return 'application/x-sgimb' }
'.sgml' { return 'text/sgml' }
'.sh' { return 'application/x-sh' }
'.shar' { return 'application/x-shar' }
'.shtml' { return 'text/html' }
'.sit' { return 'application/x-stuffit' }
'.sitemap' { return 'application/xml' }
'.skin' { return 'application/xml' }
'.skp' { return 'application/x-koan' }
'.sldm' { return 'application/vnd.ms-powerpoint.slide.macroEnabled.12' }
'.sldx' { return 'application/vnd.openxmlformats-officedocument.presentationml.slide' }
'.slk' { return 'application/vnd.ms-excel' }
'.sln' { return 'text/plain' }
'.slupkg-ms' { return 'application/x-ms-license' }
'.smd' { return 'audio/x-smd' }
'.smi' { return 'application/octet-stream' }
'.smx' { return 'audio/x-smd' }
'.smz' { return 'audio/x-smd' }
'.snd' { return 'audio/basic' }
'.snippet' { return 'application/xml' }
'.snp' { return 'application/octet-stream' }
'.sol' { return 'text/plain' }
'.sor' { return 'text/plain' }
'.spc' { return 'application/x-pkcs7-certificates' }
'.spl' { return 'application/futuresplash' }
'.spx' { return 'audio/ogg' }
'.src' { return 'application/x-wais-source' }
'.srf' { return 'text/plain' }
'.ssisdeploymentmanifest' { return 'text/xml' }
'.ssm' { return 'application/streamingmedia' }
'.sst' { return 'application/vnd.ms-pki.certstore' }
'.stl' { return 'application/vnd.ms-pki.stl' }
'.sv4cpio' { return 'application/x-sv4cpio' }
'.sv4crc' { return 'application/x-sv4crc' }
'.svc' { return 'application/xml' }
'.svg' { return 'image/svg+xml' }
'.swf' { return 'application/x-shockwave-flash' }
'.step' { return 'application/step' }
'.stp' { return 'application/step' }
'.t' { return 'application/x-troff' }
'.tar' { return 'application/x-tar' }
'.tcl' { return 'application/x-tcl' }
'.testrunconfig' { return 'application/xml' }
'.testsettings' { return 'application/xml' }
'.tex' { return 'application/x-tex' }
'.texi' { return 'application/x-texinfo' }
'.texinfo' { return 'application/x-texinfo' }
'.tgz' { return 'application/x-compressed' }
'.thmx' { return 'application/vnd.ms-officetheme' }
'.thn' { return 'application/octet-stream' }
'.tif' { return 'image/tiff' }
'.tiff' { return 'image/tiff' }
'.tlh' { return 'text/plain' }
'.tli' { return 'text/plain' }
'.toc' { return 'application/octet-stream' }
'.tr' { return 'application/x-troff' }
'.trm' { return 'application/x-msterminal' }
'.trx' { return 'application/xml' }
'.ts' { return 'video/vnd.dlna.mpeg-tts' }
'.tsv' { return 'text/tab-separated-values' }
'.ttf' { return 'application/font-sfnt' }
'.tts' { return 'video/vnd.dlna.mpeg-tts' }
'.txt' { return 'text/plain' }
'.u32' { return 'application/octet-stream' }
'.uls' { return 'text/iuls' }
'.user' { return 'text/plain' }
'.ustar' { return 'application/x-ustar' }
'.vb' { return 'text/plain' }
'.vbdproj' { return 'text/plain' }
'.vbk' { return 'video/mpeg' }
'.vbproj' { return 'text/plain' }
'.vbs' { return 'text/vbscript' }
'.vcf' { return 'text/x-vcard' }
'.vcproj' { return 'application/xml' }
'.vcs' { return 'text/plain' }
'.vcxproj' { return 'application/xml' }
'.vddproj' { return 'text/plain' }
'.vdp' { return 'text/plain' }
'.vdproj' { return 'text/plain' }
'.vdx' { return 'application/vnd.ms-visio.viewer' }
'.vml' { return 'text/xml' }
'.vscontent' { return 'application/xml' }
'.vsct' { return 'text/xml' }
'.vsd' { return 'application/vnd.visio' }
'.vsi' { return 'application/ms-vsi' }
'.vsix' { return 'application/vsix' }
'.vsixlangpack' { return 'text/xml' }
'.vsixmanifest' { return 'text/xml' }
'.vsmdi' { return 'application/xml' }
'.vspscc' { return 'text/plain' }
'.vss' { return 'application/vnd.visio' }
'.vsscc' { return 'text/plain' }
'.vssettings' { return 'text/xml' }
'.vssscc' { return 'text/plain' }
'.vst' { return 'application/vnd.visio' }
'.vstemplate' { return 'text/xml' }
'.vsto' { return 'application/x-ms-vsto' }
'.vsw' { return 'application/vnd.visio' }
'.vsx' { return 'application/vnd.visio' }
'.vtx' { return 'application/vnd.visio' }
'.wasm' { return 'application/wasm' }
'.wav' { return 'audio/wav' }
'.wave' { return 'audio/wav' }
'.wax' { return 'audio/x-ms-wax' }
'.wbk' { return 'application/msword' }
'.wbmp' { return 'image/vnd.wap.wbmp' }
'.wcm' { return 'application/vnd.ms-works' }
'.wdb' { return 'application/vnd.ms-works' }
'.wdp' { return 'image/vnd.ms-photo' }
'.webarchive' { return 'application/x-safari-webarchive' }
'.webm' { return 'video/webm' }
'.webp' { return 'image/webp' }
'.webtest' { return 'application/xml' }
'.wiq' { return 'application/xml' }
'.wiz' { return 'application/msword' }
'.wks' { return 'application/vnd.ms-works' }
'.wlmp' { return 'application/wlmoviemaker' }
'.wlpginstall' { return 'application/x-wlpg-detect' }
'.wlpginstall3' { return 'application/x-wlpg3-detect' }
'.wm' { return 'video/x-ms-wm' }
'.wma' { return 'audio/x-ms-wma' }
'.wmd' { return 'application/x-ms-wmd' }
'.wmf' { return 'application/x-msmetafile' }
'.wml' { return 'text/vnd.wap.wml' }
'.wmlc' { return 'application/vnd.wap.wmlc' }
'.wmls' { return 'text/vnd.wap.wmlscript' }
'.wmlsc' { return 'application/vnd.wap.wmlscriptc' }
'.wmp' { return 'video/x-ms-wmp' }
'.wmv' { return 'video/x-ms-wmv' }
'.wmx' { return 'video/x-ms-wmx' }
'.wmz' { return 'application/x-ms-wmz' }
'.woff' { return 'application/font-woff' }
'.woff2' { return 'application/font-woff2' }
'.wpl' { return 'application/vnd.ms-wpl' }
'.wps' { return 'application/vnd.ms-works' }
'.wri' { return 'application/x-mswrite' }
'.wrl' { return 'x-world/x-vrml' }
'.wrz' { return 'x-world/x-vrml' }
'.wsc' { return 'text/scriptlet' }
'.wsdl' { return 'text/xml' }
'.wvx' { return 'video/x-ms-wvx' }
'.x' { return 'application/directx' }
'.xaf' { return 'x-world/x-vrml' }
'.xaml' { return 'application/xaml+xml' }
'.xap' { return 'application/x-silverlight-app' }
'.xbap' { return 'application/x-ms-xbap' }
'.xbm' { return 'image/x-xbitmap' }
'.xdr' { return 'text/plain' }
'.xht' { return 'application/xhtml+xml' }
'.xhtml' { return 'application/xhtml+xml' }
'.xla' { return 'application/vnd.ms-excel' }
'.xlam' { return 'application/vnd.ms-excel.addin.macroEnabled.12' }
'.xlc' { return 'application/vnd.ms-excel' }
'.xld' { return 'application/vnd.ms-excel' }
'.xlk' { return 'application/vnd.ms-excel' }
'.xll' { return 'application/vnd.ms-excel' }
'.xlm' { return 'application/vnd.ms-excel' }
'.xls' { return 'application/vnd.ms-excel' }
'.xlsb' { return 'application/vnd.ms-excel.sheet.binary.macroEnabled.12' }
'.xlsm' { return 'application/vnd.ms-excel.sheet.macroEnabled.12' }
'.xlsx' { return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' }
'.xlt' { return 'application/vnd.ms-excel' }
'.xltm' { return 'application/vnd.ms-excel.template.macroEnabled.12' }
'.xltx' { return 'application/vnd.openxmlformats-officedocument.spreadsheetml.template' }
'.xlw' { return 'application/vnd.ms-excel' }
'.xml' { return 'text/xml' }
'.xmp' { return 'application/octet-stream' }
'.xmta' { return 'application/xml' }
'.xof' { return 'x-world/x-vrml' }
'.xoml' { return 'text/plain' }
'.xpm' { return 'image/x-xpixmap' }
'.xps' { return 'application/vnd.ms-xpsdocument' }
'.xrm-ms' { return 'text/xml' }
'.xsc' { return 'application/xml' }
'.xsd' { return 'text/xml' }
'.xsf' { return 'text/xml' }
'.xsl' { return 'text/xml' }
'.xslt' { return 'text/xml' }
'.xsn' { return 'application/octet-stream' }
'.xss' { return 'application/xml' }
'.xspf' { return 'application/xspf+xml' }
'.xtp' { return 'application/octet-stream' }
'.xwd' { return 'image/x-xwindowdump' }
'.yaml' { return 'application/x-yaml' }
'.yml' { return 'application/x-yaml' }
'.z' { return 'application/x-compress' }
'.zip' { return 'application/zip' }
default { return (Resolve-PodeValue -Check $DefaultIsNull -TrueValue $null -FalseValue 'text/plain') }
}
}
function Get-PodeStatusDescription
{
param (
[Parameter()]
[int]
$StatusCode
)
switch ($StatusCode)
{
100 { return 'Continue' }
101 { return 'Switching Protocols' }
102 { return 'Processing' }
103 { return 'Early Hints' }
200 { return 'OK' }
201 { return 'Created' }
202 { return 'Accepted' }
203 { return 'Non-Authoritative Information' }
204 { return 'No Content' }
205 { return 'Reset Content' }
206 { return 'Partial Content' }
207 { return 'Multi-Status' }
208 { return 'Already Reported' }
226 { return 'IM Used' }
300 { return 'Multiple Choices' }
301 { return 'Moved Permanently' }
302 { return 'Found' }
303 { return 'See Other' }
304 { return 'Not Modified' }
305 { return 'Use Proxy' }
306 { return 'Switch Proxy' }
307 { return 'Temporary Redirect' }
308 { return 'Permanent Redirect' }
400 { return 'Bad Request' }
401 { return 'Unauthorized' }
402 { return 'Payment Required' }
403 { return 'Forbidden' }
404 { return 'Not Found' }
405 { return 'Method Not Allowed' }
406 { return 'Not Acceptable' }
407 { return 'Proxy Authentication Required' }
408 { return 'Request Timeout' }
409 { return 'Conflict' }
410 { return 'Gone' }
411 { return 'Length Required' }
412 { return 'Precondition Failed' }
413 { return 'Payload Too Large' }
414 { return 'URI Too Long' }
415 { return 'Unsupported Media Type' }
416 { return 'Range Not Satisfiable' }
417 { return 'Expectation Failed' }
418 { return "I'm a Teapot" }
419 { return 'Page Expired' }
420 { return 'Enhance Your Calm' }
421 { return 'Misdirected Request' }
422 { return 'Unprocessable Entity' }
423 { return 'Locked' }
424 { return 'Failed Dependency' }
426 { return 'Upgrade Required' }
428 { return 'Precondition Required' }
429 { return 'Too Many Requests' }
431 { return 'Request Header Fields Too Large' }
440 { return 'Login Time-out' }
450 { return 'Blocked by Windows Parental Controls' }
451 { return 'Unavailable For Legal Reasons' }
500 { return 'Internal Server Error' }
501 { return 'Not Implemented' }
502 { return 'Bad Gateway' }
503 { return 'Service Unavailable' }
504 { return 'Gateway Timeout' }
505 { return 'HTTP Version Not Supported' }
506 { return 'Variant Also Negotiates' }
507 { return 'Insufficient Storage' }
508 { return 'Loop Detected' }
510 { return 'Not Extended' }
511 { return 'Network Authentication Required' }
526 { return 'Invalid SSL Certificate' }
default { return ([string]::Empty) }
}
}
function Update-PodeServerRequestMetrics
{
param(
[Parameter()]
[hashtable]
$WebEvent
)
if ($null -eq $WebEvent) {
return
}
# status code
$status = "$($WebEvent.Response.StatusCode)"
# metrics to update
$metrics = @($PodeContext.Metrics.Requests)
if ($null -ne $WebEvent.Route) {
$metrics += $WebEvent.Route.Metrics.Requests
}
# increment the request metrics
foreach ($metric in $metrics) {
Lock-PodeObject -Object $metric -ScriptBlock {
$metric.Total++
if (!$metric.StatusCodes.ContainsKey($status)) {
$metric.StatusCodes[$status] = 0
}
$metric.StatusCodes[$status]++
}
}
}
function Invoke-PodeMiddleware
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$WebEvent,
[Parameter()]
$Middleware,
[Parameter()]
[string]
$Route
)
# if there's no middleware, do nothing
if (($null -eq $Middleware) -or ($Middleware.Length -eq 0)) {
return $true
}
# filter the middleware down by route (retaining order)
if (![string]::IsNullOrWhiteSpace($Route))
{
$Middleware = @(foreach ($mware in $Middleware) {
if ($null -eq $mware) {
continue
}
if ([string]::IsNullOrWhiteSpace($mware.Route) -or ($mware.Route -ieq '/') -or ($mware.Route -ieq $Route) -or ($Route -imatch "^$($mware.Route)$")) {
$mware
}
})
}
# continue or halt?
$continue = $true
# loop through each of the middleware, invoking the next if it returns true
foreach ($midware in @($Middleware))
{
if (($null -eq $midware) -or ($null -eq $midware.Logic)) {
continue
}
try {
$_args = @($midware.Arguments)
if ($null -ne $midware.UsingVariables) {
$_vars = @()
foreach ($_var in $midware.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
$continue = Invoke-PodeScriptBlock -ScriptBlock $midware.Logic -Arguments $_args -Return -Scoped -Splat
}
catch {
Set-PodeResponseStatus -Code 500 -Exception $_
$continue = $false
$_ | Write-PodeErrorLog
}
if (!$continue) {
break
}
}
return $continue
}
function New-PodeMiddlewareInternal
{
[OutputType([hashtable])]
param(
[Parameter(Mandatory=$true)]
[scriptblock]
$ScriptBlock,
[Parameter()]
[string]
$Route,
[Parameter()]
[object[]]
$ArgumentList,
[Parameter(Mandatory=$true)]
[System.Management.Automation.SessionState]
$PSSession
)
if (Test-PodeIsEmpty $ScriptBlock) {
throw "[Middleware]: No ScriptBlock supplied"
}
# if route is empty, set it to root
$Route = ConvertTo-PodeRouteRegex -Path $Route
# check if the scriptblock has any using vars
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSSession
# create the middleware hashtable from a scriptblock
$HashTable = @{
Route = $Route
Logic = $ScriptBlock
Arguments = $ArgumentList
UsingVariables = $usingVars
}
# return the middleware, so it can be cached/added at a later date
return $HashTable
}
function Get-PodeInbuiltMiddleware
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Name,
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[scriptblock]
$ScriptBlock
)
# check if middleware contains an override
$override = ($PodeContext.Server.Middleware | Where-Object { $_.Name -ieq $Name })
# if override there, remove it from middleware
if ($override) {
$PodeContext.Server.Middleware = @($PodeContext.Server.Middleware | Where-Object { $_.Name -ine $Name })
$ScriptBlock = $override.Logic
}
# return the script
return @{
Name = $Name
Logic = $ScriptBlock
}
}
function Get-PodeAccessMiddleware
{
return (Get-PodeInbuiltMiddleware -Name '__pode_mw_access__' -ScriptBlock {
# are there any rules?
if (($PodeContext.Server.Access.Allow.Count -eq 0) -and ($PodeContext.Server.Access.Deny.Count -eq 0)) {
return $true
}
# ensure the request IP address is allowed
if (!(Test-PodeIPAccess -IP $WebEvent.Request.RemoteEndPoint.Address)) {
Set-PodeResponseStatus -Code 403
return $false
}
# request is allowed
return $true
})
}
function Get-PodeLimitMiddleware
{
return (Get-PodeInbuiltMiddleware -Name '__pode_mw_rate_limit__' -ScriptBlock {
# are there any rules?
if ($PodeContext.Server.Limits.Rules.Count -eq 0) {
return $true
}
# check the request IP address has not hit a rate limit
if (!(Test-PodeIPLimit -IP $WebEvent.Request.RemoteEndPoint.Address)) {
Set-PodeResponseStatus -Code 429
return $false
}
# check the route
if (!(Test-PodeRouteLimit -Path $WebEvent.Path)) {
Set-PodeResponseStatus -Code 429
return $false
}
# check the endpoint
if (!(Test-PodeEndpointLimit -EndpointName $WebEvent.Endpoint.Name)) {
Set-PodeResponseStatus -Code 429
return $false
}
# request is allowed
return $true
})
}
function Get-PodePublicMiddleware
{
return (Get-PodeInbuiltMiddleware -Name '__pode_mw_static_content__' -ScriptBlock {
# only find public static content here
$path = Find-PodePublicRoute -Path $WebEvent.Path
if ([string]::IsNullOrWhiteSpace($path)) {
return $true
}
# check current state of caching
$cachable = Test-PodeRouteValidForCaching -Path $WebEvent.Path
# write the file to the response
Write-PodeFileResponse -Path $path -MaxAge $PodeContext.Server.Web.Static.Cache.MaxAge -Cache:$cachable
# public static content found, stop
return $false
})
}
function Get-PodeRouteValidateMiddleware
{
return @{
Name = '__pode_mw_route_validation__'
Logic = {
# check if the path is static route first, then check the main routes
$route = Find-PodeStaticRoute -Path $WebEvent.Path -EndpointName $WebEvent.Endpoint.Name
if ($null -eq $route) {
$route = Find-PodeRoute -Method $WebEvent.Method -Path $WebEvent.Path -EndpointName $WebEvent.Endpoint.Name -CheckWildMethod
}
# if there's no route defined, it's a 404 - or a 405 if a route exists for any other method
if ($null -eq $route) {
# check if a route exists for another method
$methods = @('DELETE', 'GET', 'HEAD', 'MERGE', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE')
$diff_route = @(foreach ($method in $methods) {
$r = Find-PodeRoute -Method $method -Path $WebEvent.Path -EndpointName $WebEvent.Endpoint.Name
if ($null -ne $r) {
$r
break
}
})[0]
if ($null -ne $diff_route) {
Set-PodeResponseStatus -Code 405
return $false
}
# otheriwse, it's a 404
Set-PodeResponseStatus -Code 404
return $false
}
# check if static and split
if ($null -ne $route.Content) {
$WebEvent.StaticContent = $route.Content
$route = $route.Route
}
# set the route parameters
$WebEvent.Parameters = @{}
if ($WebEvent.Path -imatch "$($route.Path)$") {
$WebEvent.Parameters = $Matches
}
# set the route on the WebEvent
$WebEvent.Route = $route
# override the content type from the route if it's not empty
if (![string]::IsNullOrWhiteSpace($route.ContentType)) {
$WebEvent.ContentType = $route.ContentType
}
# override the transfer encoding from the route if it's not empty
if (![string]::IsNullOrWhiteSpace($route.TransferEncoding)) {
$WebEvent.TransferEncoding = $route.TransferEncoding
}
# set the content type for any pages for the route if it's not empty
$WebEvent.ErrorType = $route.ErrorType
# route exists
return $true
}
}
}
function Get-PodeBodyMiddleware
{
return (Get-PodeInbuiltMiddleware -Name '__pode_mw_body_parsing__' -ScriptBlock {
try {
# attempt to parse that data
$result = ConvertFrom-PodeRequestContent -Request $WebEvent.Request -ContentType $WebEvent.ContentType -TransferEncoding $WebEvent.TransferEncoding
# set session data
$WebEvent.Data = $result.Data
$WebEvent.Files = $result.Files
# payload parsed
return $true
}
catch {
Set-PodeResponseStatus -Code 400 -Exception $_
return $false
}
})
}
function Get-PodeQueryMiddleware
{
return (Get-PodeInbuiltMiddleware -Name '__pode_mw_query_parsing__' -ScriptBlock {
try {
# set the query string from the request
$WebEvent.Query = (ConvertFrom-PodeNameValueToHashTable -Collection $WebEvent.Request.QueryString)
return $true
}
catch {
Set-PodeResponseStatus -Code 400 -Exception $_
return $false
}
})
}
function Get-PodeCookieMiddleware
{
return (Get-PodeInbuiltMiddleware -Name '__pode_mw_cookie_parsing__' -ScriptBlock {
# if cookies already set, return
if ($WebEvent.Cookies.Count -gt 0) {
return $true
}
# if the request's header has no cookies, return
$h_cookie = (Get-PodeHeader -Name 'Cookie')
if ([string]::IsNullOrWhiteSpace($h_cookie)) {
return $true
}
# parse the cookies from the header
$cookies = @($h_cookie -split '; ')
$WebEvent.Cookies = @{}
foreach ($cookie in $cookies) {
$atoms = $cookie.Split('=', 2)
$value = [string]::Empty
if ($atoms.Length -gt 1) {
foreach ($atom in $atoms[1..($atoms.Length - 1)]) {
$value += $atom
}
}
$WebEvent.Cookies[$atoms[0]] = [System.Net.Cookie]::new($atoms[0], $value)
}
return $true
})
}
function Get-PodeRandomName
{
$adjs = @(
"admiring",
"agitated",
"blissful",
"dazzling",
"ecstatic",
"eloquent",
"friendly",
"gracious",
"hardcore",
"laughing",
"peaceful",
"pedantic",
"reverent",
"romantic",
"trusting",
"vigilant",
"vigorous",
"wizardly",
"youthful"
)
$names = @(
"almeida",
"babbage",
"bardeen",
"shannon",
"davinci",
"feynman",
"galileo",
"goodall",
"hawking",
"hermann",
"hodgkin",
"hypatia",
"jackson",
"johnson",
"kapitsa",
"keldysh",
"khorana",
"lalande",
"lamport",
"leavitt",
"lumiere",
"mcnulty",
"meitner",
"mestorf",
"murdock",
"neumann",
"noether",
"pasteur",
"perlman",
"poitras",
"ptolemy",
"ritchie",
"shirley",
"swanson",
"swirles",
"vaughan",
"volhard",
"villani",
"wescoff",
"wozniak"
)
$adjsRand = (Get-Random -Minimum 0 -Maximum $adjs.Length)
$namesRand = (Get-Random -Minimum 0 -Maximum $names.Length)
return "$($adjs[$adjsRand])_$($names[$namesRand])"
}
function ConvertTo-PodeOAContentTypeSchema
{
param(
[Parameter(ValueFromPipeline=$true)]
[hashtable]
$Schemas
)
if (Test-PodeIsEmpty $Schemas) {
return $null
}
# ensure all content types are valid
foreach ($type in $Schemas.Keys) {
if ($type -inotmatch '^\w+\/[\w\.\+-]+$') {
throw "Invalid content-type found for schema: $($type)"
}
}
# convert each schema to openapi format
return (ConvertTo-PodeOAObjectSchema -Schemas $Schemas)
}
function ConvertTo-PodeOAHeaderSchema
{
param(
[Parameter(ValueFromPipeline=$true)]
[hashtable]
$Schemas
)
if (Test-PodeIsEmpty $Schemas) {
return $null
}
# convert each schema to openapi format
return (ConvertTo-PodeOAObjectSchema -Schemas $Schemas)
}
function ConvertTo-PodeOAObjectSchema
{
param(
[Parameter(ValueFromPipeline=$true)]
[hashtable]
$Schemas
)
# convert each schema to openapi format
$obj = @{}
foreach ($type in $Schemas.Keys) {
$obj[$type] = @{
schema = $null
}
# add a shared component schema reference
if ($Schemas[$type] -is [string]) {
if (!(Test-PodeOAComponentSchema -Name $Schemas[$type])) {
throw "The OpenApi component schema doesn't exist: $($Schemas[$type])"
}
$obj[$type].schema = @{
'$ref' = "#/components/schemas/$($Schemas[$type])"
}
}
# add a set schema object
else {
$obj[$type].schema = ($Schemas[$type] | ConvertTo-PodeOASchemaProperty)
}
}
return $obj
}
function Test-PodeOAComponentSchema
{
param(
[Parameter(Mandatory=$true)]
[string]
$Name
)
return $PodeContext.Server.OpenAPI.components.schemas.ContainsKey($Name)
}
function Test-PodeOAComponentResponse
{
param(
[Parameter(Mandatory=$true)]
[string]
$Name
)
return $PodeContext.Server.OpenAPI.components.responses.ContainsKey($Name)
}
function Test-PodeOAComponentRequestBody
{
param(
[Parameter(Mandatory=$true)]
[string]
$Name
)
return $PodeContext.Server.OpenAPI.components.requestBodies.ContainsKey($Name)
}
function Test-PodeOAComponentParameter
{
param(
[Parameter(Mandatory=$true)]
[string]
$Name
)
return $PodeContext.Server.OpenAPI.components.parameters.ContainsKey($Name)
}
function ConvertTo-PodeOASchemaProperty
{
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$Property
)
# base schema type
$schema = @{
type = $Property.type
format = $Property.format
}
# are we using an array?
if ($Property.array) {
$Property.array = $false
$schema = @{
type = 'array'
items = ($Property | ConvertTo-PodeOASchemaProperty)
}
}
# are we using an object?
if ($Property.object) {
$Property.object = $false
$schema = @{
type = 'object'
properties = (ConvertTo-PodeOASchemaObjectProperty -Properties $Property)
}
if ($Property.required) {
$schema['required'] = @($Property.name)
}
}
if ($Property.type -ieq 'object') {
$schema['properties'] = (ConvertTo-PodeOASchemaObjectProperty -Properties $Property.properties)
$schema['required'] = @(($Property.properties | Where-Object { $_.required }).name)
}
return $schema
}
function ConvertTo-PodeOASchemaObjectProperty
{
param(
[Parameter(Mandatory=$true)]
[hashtable[]]
$Properties
)
$schema = @{}
foreach ($prop in $Properties) {
$schema[$prop.name] = ($prop | ConvertTo-PodeOASchemaProperty)
}
return $schema
}
function Get-PodeOpenApiDefinitionInternal
{
param(
[Parameter(Mandatory=$true)]
[string]
$Title,
[Parameter()]
[string]
$Version,
[Parameter()]
[string]
$Description,
[Parameter()]
[string]
$RouteFilter,
[Parameter()]
[string]
$Protocol,
[Parameter()]
[string]
$Address,
[Parameter()]
[string]
$EndpointName,
[switch]
$RestrictRoutes
)
# set the openapi version
$def = @{
openapi = '3.0.2'
}
# metadata
$def['info'] = @{
title = $Title
version = $Version
description = $Description
}
# servers
$def['servers'] = $null
if (!$RestrictRoutes -and ($PodeContext.Server.Endpoints.Count -gt 1)) {
$def.servers = @(foreach ($endpoint in $PodeContext.Server.Endpoints.Values) {
@{
url = $endpoint.Url
description = (Protect-PodeValue -Value $endpoint.Description -Default $endpoint.Name)
}
})
}
# components
$def['components'] = $PodeContext.Server.OpenAPI.components
# auth/security components
if ($PodeContext.Server.Authentications.Count -gt 0) {
if ($null -eq $def.components.securitySchemes) {
$def.components.securitySchemes = @{}
}
foreach ($authName in $PodeContext.Server.Authentications.Keys) {
$authType = (Find-PodeAuth -Name $authName).Scheme
$def.components.securitySchemes[($authName -replace '\s+', '')] = @{
type = $authType.Scheme.ToLowerInvariant()
scheme = $authType.Name.ToLowerInvariant()
}
}
if ($PodeContext.Server.OpenAPI.Security.Length -gt 0) {
$def['security'] = @($PodeContext.Server.OpenAPI.Security.Definition)
}
}
# paths
$def['paths'] = @{}
$filter = "^$($RouteFilter)"
foreach ($method in $PodeContext.Server.Routes.Keys) {
foreach ($path in $PodeContext.Server.Routes[$method].Keys) {
# does it match the route?
if ($path -inotmatch $filter) {
continue
}
# the current route
$_routes = @($PodeContext.Server.Routes[$method][$path])
if ($RestrictRoutes) {
$_routes = @(Get-PodeRoutesByUrl -Routes $_routes -EndpointName $EndpointName)
}
# continue if no routes
if (($_routes.Length -eq 0) -or ($null -eq $_routes[0])) {
continue
}
# get the first route for base definition
$_route = $_routes[0]
# do nothing if it has no responses set
if ($_route.OpenApi.Responses.Count -eq 0) {
continue
}
# add path to defintion
if ($null -eq $def.paths[$_route.OpenApi.Path]) {
$def.paths[$_route.OpenApi.Path] = @{}
}
# add path's http method to defintition
$def.paths[$_route.OpenApi.Path][$method] = @{
summary = $_route.OpenApi.Summary
description = $_route.OpenApi.Description
operationId = $_route.OpenApi.OperationId
tags = @($_route.OpenApi.Tags)
deprecated = $_route.OpenApi.Deprecated
responses = $_route.OpenApi.Responses
parameters = $_route.OpenApi.Parameters
requestBody = $_route.OpenApi.RequestBody
servers = $null
security = @($_route.OpenApi.Authentication)
}
# add global authentication for route
if (($null -ne $def['security']) -and ($def['security'].Length -gt 0)) {
foreach ($sec in $PodeContext.Server.OpenAPI.Security) {
if ([string]::IsNullOrWhiteSpace($sec.Route) -or ($sec.Route -ieq '/') -or ($sec.Route -ieq $_route.OpenApi.Path) -or ($_route.OpenApi.Path -imatch "^$($sec.Route)$")) {
$def.paths[$_route.OpenApi.Path][$method].security += $sec.Definition
}
}
}
# add any custom server endpoints for route
foreach ($_route in $_routes) {
if ([string]::IsNullOrWhiteSpace($_route.Endpoint.Address) -or ($_route.Endpoint.Address -ieq '*:*')) {
continue
}
if ($null -eq $def.paths[$_route.OpenApi.Path][$method].servers) {
$def.paths[$_route.OpenApi.Path][$method].servers = @()
}
$serverDef = $null
if (![string]::IsNullOrWhiteSpace($_route.Endpoint.Name)) {
$serverDef = @{
url = (Get-PodeEndpointByName -Name $_route.Endpoint.Name).Url
}
}
else {
$serverDef = @{
url = "$($_route.Endpoint.Protocol)://$($_route.Endpoint.Address)"
}
}
if ($null -ne $serverDef) {
$def.paths[$_route.OpenApi.Path][$method].servers += $serverDef
}
}
}
}
# remove all null values (swagger hates them)
$def | Remove-PodeNullKeysFromHashtable
return $def
}
function ConvertTo-PodeOAPropertyFromCmdletParameter
{
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[System.Management.Automation.ParameterMetadata]
$Parameter
)
if ($Parameter.SwitchParameter -or ($Parameter.ParameterType.Name -ieq 'boolean')) {
New-PodeOABoolProperty -Name $Parameter.Name
}
else {
switch ($Parameter.ParameterType.Name) {
{ @('int32', 'int64') -icontains $_ } {
New-PodeOAIntProperty -Name $Parameter.Name -Format $_
}
{ @('double', 'float') -icontains $_ } {
New-PodeOANumberProperty -Name $Parameter.Name -Format $_
}
}
}
New-PodeOAStringProperty -Name $Parameter.Name
}
function Get-PodeOABaseObject
{
return @{
Path = $null
Title = $null
components = @{
schemas = @{}
responses = @{}
requestBodies = @{}
parameters = @{}
}
Security = @()
}
}
function Set-PodeOAAuth
{
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[ValidateNotNullOrEmpty()]
[hashtable[]]
$Route,
[Parameter()]
[string[]]
$Name
)
foreach ($n in @($Name)) {
if (!(Test-PodeAuth -Name $n)) {
throw "Authentication method does not exist: $($n)"
}
}
foreach ($r in @($Route)) {
$r.OpenApi.Authentication = @(foreach ($n in @($Name)) {
@{
"$($n -replace '\s+', '')" = @()
}
})
}
}
function Set-PodeOAGlobalAuth
{
param(
[Parameter()]
[string]
$Name,
[Parameter()]
[string]
$Route
)
if (!(Test-PodeAuth -Name $Name)) {
throw "Authentication method does not exist: $($Name)"
}
if (Test-PodeIsEmpty $PodeContext.Server.OpenAPI.Security) {
$PodeContext.Server.OpenAPI.Security = @()
}
$PodeContext.Server.OpenAPI.Security += @{
Definition = @{
"$($Name -replace '\s+', '')" = @()
}
Route = (ConvertTo-PodeRouteRegex -Path $Route)
}
}
using namespace Pode
function Start-PodeWebServer
{
param (
[switch]
$Browse
)
# setup any inbuilt middleware
$inbuilt_middleware = @(
(Get-PodeAccessMiddleware),
(Get-PodeLimitMiddleware),
(Get-PodePublicMiddleware),
(Get-PodeRouteValidateMiddleware),
(Get-PodeBodyMiddleware),
(Get-PodeQueryMiddleware),
(Get-PodeCookieMiddleware)
)
$PodeContext.Server.Middleware = ($inbuilt_middleware + $PodeContext.Server.Middleware)
# work out which endpoints to listen on
$endpoints = @()
@(Get-PodeEndpoints -Type Http) | ForEach-Object {
# get the ip address
$_ip = [string]($_.Address)
$_ip = (Get-PodeIPAddressesForHostname -Hostname $_ip -Type All | Select-Object -First 1)
$_ip = (Get-PodeIPAddress $_ip)
# add endpoint to list
$endpoints += @{
Address = $_ip
Hostname = $_.HostName
IsIPAddress = $_.IsIPAddress
Port = $_.Port
Certificate = $_.Certificate.Raw
AllowClientCertificate = $_.Certificate.AllowClientCertificate
Url = $_.Url
}
}
# create the listener
$listener = (. ([scriptblock]::Create("New-Pode$($PodeContext.Server.ListenerType)Listener -CancellationToken `$PodeContext.Tokens.Cancellation.Token -Type 'Http'")))
$listener.ErrorLoggingEnabled = (Test-PodeErrorLoggingEnabled)
try
{
# register endpoints on the listener
$endpoints | ForEach-Object {
$socket = (. ([scriptblock]::Create("New-Pode$($PodeContext.Server.ListenerType)ListenerSocket -Address `$_.Address -Port `$_.Port -SslProtocols `$PodeContext.Server.Sockets.Ssl.Protocols -Certificate `$_.Certificate -AllowClientCertificate `$_.AllowClientCertificate")))
$socket.ReceiveTimeout = $PodeContext.Server.Sockets.ReceiveTimeout
if (!$_.IsIPAddress) {
$socket.Hostnames.Add($_.HostName)
}
$listener.Add($socket)
}
$listener.Start()
$PodeContext.Listeners += $listener
}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
Close-PodeDisposable -Disposable $listener
throw $_.Exception
}
# script for listening out for incoming requests
$listenScript = {
param(
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Listener,
[Parameter(Mandatory=$true)]
[int]
$ThreadId
)
try
{
while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested)
{
# get request and response
$context = (Wait-PodeTask -Task $Listener.GetContextAsync($PodeContext.Tokens.Cancellation.Token))
try
{
try
{
$Request = $context.Request
$Response = $context.Response
# reset with basic event data
$WebEvent = @{
OnEnd = @()
Auth = @{}
Response = $Response
Request = $Request
Lockable = $PodeContext.Lockable
Path = [System.Web.HttpUtility]::UrlDecode($Request.Url.AbsolutePath)
Method = $Request.HttpMethod.ToLowerInvariant()
Query = $null
Endpoint = @{
Protocol = $Request.Url.Scheme
Address = $Request.Host
Name = $null
}
ContentType = $Request.ContentType
ErrorType = $null
Cookies = @{}
PendingCookies = @{}
Parameters = $null
Data = $null
Files = $null
Streamed = $true
Route = $null
StaticContent = $null
Timestamp = [datetime]::UtcNow
TransferEncoding = $null
AcceptEncoding = $null
}
# accept/transfer encoding
$WebEvent.TransferEncoding = (Get-PodeTransferEncoding -TransferEncoding (Get-PodeHeader -Name 'Transfer-Encoding') -ThrowError)
$WebEvent.AcceptEncoding = (Get-PodeAcceptEncoding -AcceptEncoding (Get-PodeHeader -Name 'Accept-Encoding') -ThrowError)
# endpoint name
$WebEvent.Endpoint.Name = (Find-PodeEndpointName -Protocol $WebEvent.Endpoint.Protocol -Address $WebEvent.Endpoint.Address -LocalAddress $WebEvent.Request.LocalEndPoint)
# add logging endware for post-request
Add-PodeRequestLogEndware -WebEvent $WebEvent
# stop now if the request has an error
if ($null -ne $Request.Error) {
$Request.Error | Write-PodeErrorLog -CheckInnerException
throw $Request.Error
}
# invoke global and route middleware
if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $PodeContext.Server.Middleware -Route $WebEvent.Path)) {
if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $WebEvent.Route.Middleware))
{
# invoke the route
if ($null -ne $WebEvent.StaticContent) {
if ($WebEvent.StaticContent.IsDownload) {
Set-PodeResponseAttachment -Path $WebEvent.Path -EndpointName $WebEvent.Endpoint.Name
}
else {
$cachable = $WebEvent.StaticContent.IsCachable
Write-PodeFileResponse -Path $WebEvent.StaticContent.Source -MaxAge $PodeContext.Server.Web.Static.Cache.MaxAge -Cache:$cachable
}
}
elseif ($null -ne $WebEvent.Route.Logic) {
$_args = @($WebEvent.Route.Arguments)
if ($null -ne $WebEvent.Route.UsingVariables) {
$_vars = @()
foreach ($_var in $WebEvent.Route.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
Invoke-PodeScriptBlock -ScriptBlock $WebEvent.Route.Logic -Arguments $_args -Scoped -Splat
}
}
}
}
catch [System.OperationCanceledException] {}
catch [System.Net.Http.HttpRequestException] {
$code = [int]($_.Exception.Data['PodeStatusCode'])
if ($code -le 0) {
$code = 400
}
Set-PodeResponseStatus -Code $code -Exception $_
}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
Set-PodeResponseStatus -Code 500 -Exception $_
}
finally {
Update-PodeServerRequestMetrics -WebEvent $WebEvent
}
# invoke endware specifc to the current web event
$_endware = ($WebEvent.OnEnd + @($PodeContext.Server.Endware))
Invoke-PodeEndware -WebEvent $WebEvent -Endware $_endware
}
finally {
$WebEvent = $null
Close-PodeDisposable -Disposable $context
}
}
}
catch [System.OperationCanceledException] {}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
throw $_.Exception
}
}
# start the runspace for listening on x-number of threads
1..$PodeContext.Threads.General | ForEach-Object {
Add-PodeRunspace -Type Web -ScriptBlock $listenScript -Parameters @{ 'Listener' = $listener; 'ThreadId' = $_ }
}
# script to keep web server listening until cancelled
$waitScript = {
param(
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Listener
)
try {
while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested) {
Start-Sleep -Seconds 1
}
}
catch [System.OperationCanceledException] {}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
throw $_.Exception
}
finally {
Close-PodeDisposable -Disposable $Listener
}
}
Add-PodeRunspace -Type Web -ScriptBlock $waitScript -Parameters @{ 'Listener' = $listener }
# browse to the first endpoint, if flagged
if ($Browse) {
Start-Process $endpoints[0].Url
}
return @($endpoints.Url)
}
function New-PodeListener
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[System.Threading.CancellationToken]
$CancellationToken,
[Parameter(Mandatory=$true)]
[PodeListenerType]
$Type
)
return [PodeListener]::new($CancellationToken, $Type)
}
function New-PodeListenerSocket
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[ipaddress]
$Address,
[Parameter(Mandatory=$true)]
[int]
$Port,
[Parameter()]
[System.Security.Authentication.SslProtocols]
$SslProtocols,
[Parameter()]
[X509Certificate]
$Certificate,
[Parameter()]
[bool]
$AllowClientCertificate
)
return [PodeSocket]::new($Address, $Port, $SslProtocols, $Certificate, $AllowClientCertificate)
}
function Show-PodeErrorPage
{
param (
[Parameter()]
[int]
$Code,
[Parameter()]
[string]
$Description,
[Parameter()]
$Exception,
[Parameter()]
[string]
$ContentType
)
# error page info
$errorPage = Find-PodeErrorPage -Code $Code -ContentType $ContentType
# if no page found, return
if (Test-PodeIsEmpty $errorPage) {
return
}
# if exception trace showing enabled then build the exception details object
$ex = $null
if (!(Test-PodeIsEmpty $Exception) -and $PodeContext.Server.Web.ErrorPages.ShowExceptions) {
$ex = @{
'Message' = [System.Web.HttpUtility]::HtmlEncode($Exception.Exception.Message);
'StackTrace' = [System.Web.HttpUtility]::HtmlEncode($Exception.ScriptStackTrace);
'Line' = [System.Web.HttpUtility]::HtmlEncode($Exception.InvocationInfo.PositionMessage);
'Category' = [System.Web.HttpUtility]::HtmlEncode($Exception.CategoryInfo.ToString());
}
}
# setup the data object for dynamic pages
$data = @{
'Url' = (Get-PodeUrl);
'Status' = @{
'Code' = $Code;
'Description' = $Description;
};
'Exception' = $ex;
'ContentType' = $errorPage.ContentType;
}
# write the error page to the stream
Write-PodeFileResponse -Path $errorPage.Path -Data $data -ContentType $errorPage.ContentType
}
function Close-PodeTcpConnection
{
param (
[Parameter()]
$Client,
[Parameter(ParameterSetName='Quit')]
[string]
$Message,
[Parameter(ParameterSetName='Quit')]
[switch]
$Quit
)
if ($null -eq $Client) {
$Client = $TcpEvent.Client
}
if ($null -ne $Client) {
if ($Quit -and $Client.Connected) {
if ([string]::IsNullOrWhiteSpace($Message)) {
$Message = '221 Bye'
}
Write-PodeTcpClient -Message $Message
}
Close-PodeDisposable -Disposable $Client -Close
}
}
function Test-PodeRoute
{
param (
[Parameter(Mandatory=$true)]
[ValidateSet('DELETE', 'GET', 'HEAD', 'MERGE', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE', 'STATIC', '*')]
[string]
$Method,
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Path,
[Parameter()]
[string]
$EndpointName,
[switch]
$CheckWildMethod
)
$route = Find-PodeRoute -Method $Method -Path $Path -EndpointName $EndpointName -CheckWildMethod:$CheckWildMethod
return ($null -ne $route)
}
function Find-PodeRoute
{
param (
[Parameter(Mandatory=$true)]
[ValidateSet('DELETE', 'GET', 'HEAD', 'MERGE', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE', 'STATIC', '*')]
[string]
$Method,
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Path,
[Parameter()]
[string]
$EndpointName,
[switch]
$CheckWildMethod
)
# first, if supplied, check the wildcard method
if ($CheckWildMethod -and ($PodeContext.Server.Routes['*'].Count -ne 0)) {
$found = Find-PodeRoute -Method '*' -Path $Path -EndpointName $EndpointName
if ($null -ne $found) {
return $found
}
}
# is this a static route?
$isStatic = ($Method -ieq 'static')
# first ensure we have the method
$_method = $PodeContext.Server.Routes[$Method]
if ($null -eq $_method) {
return $null
}
# if we have a perfect match for the route, return it if the protocol is right
$found = Get-PodeRouteByUrl -Routes $_method[$Path] -EndpointName $EndpointName
if (!$isStatic -and ($null -ne $found)) {
return $found
}
# otherwise, attempt to match on regex parameters
else {
# match the path to routes on regex (first match only)
$valid = @(foreach ($key in $_method.Keys) {
if ($Path -imatch "^$($key)$") {
$key
break
}
})[0]
if ($null -eq $valid) {
return $null
}
# is the route valid for any protocols/endpoints?
$found = Get-PodeRouteByUrl -Routes $_method[$valid] -EndpointName $EndpointName
if ($null -eq $found) {
return $null
}
return $found
}
}
function Find-PodePublicRoute
{
param(
[Parameter(Mandatory=$true)]
[string]
$Path
)
$source = $null
$publicPath = $PodeContext.Server.InbuiltDrives['public']
# reutrn null if there is no public directory
if ([string]::IsNullOrWhiteSpace($publicPath)) {
return $source
}
# use the public static directory (but only if path is a file, and a public dir is present)
if (Test-PodePathIsFile $Path) {
$source = (Join-Path $publicPath $Path)
if (!(Test-PodePath -Path $source -NoStatus)) {
$source = $null
}
}
# return the route details
return $source
}
function Find-PodeStaticRoute
{
param(
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[string]
$EndpointName,
[switch]
$CheckPublic
)
# attempt to get a static route for the path
$found = Find-PodeRoute -Method 'static' -Path $Path -EndpointName $EndpointName
$download = ([bool]$found.Download)
$source = $null
# if we have a defined static route, use that
if ($null -ne $found) {
# see if we have a file
$file = [string]::Empty
if ($Path -imatch "$($found.Path)$") {
$file = (Protect-PodeValue -Value $Matches['file'] -Default ([string]::Empty))
}
# if there's no file, we need to check defaults
if (!$found.Download -and !(Test-PodePathIsFile $file) -and (Get-PodeCount @($found.Defaults)) -gt 0)
{
if ((Get-PodeCount @($found.Defaults)) -eq 1) {
$file = Join-PodePaths @($file, @($found.Defaults)[0])
}
else {
foreach ($def in $found.Defaults) {
if (Test-PodePath (Join-Path $found.Source $def) -NoStatus) {
$file = Join-PodePaths @($file, $def)
break
}
}
}
}
$source = (Join-Path $found.Source $file)
}
# check public, if flagged
if ($CheckPublic -and !(Test-PodePath -Path $source -NoStatus)) {
$source = Find-PodePublicRoute -Path $Path
$download = $false
$found = $null
}
# return nothing if no source
if ([string]::IsNullOrWhiteSpace($source)) {
return $null
}
# return the route details
return @{
Content = @{
Source = $source
IsDownload = $download
IsCachable = (Test-PodeRouteValidForCaching -Path $Path)
}
Route = $found
}
}
function Test-PodeRouteValidForCaching
{
param(
[Parameter(Mandatory=$true)]
[string]
$Path
)
# check current state of caching
$config = $PodeContext.Server.Web.Static.Cache
$caching = $config.Enabled
# if caching, check include/exclude
if ($caching) {
if (($null -ne $config.Exclude) -and ($Path -imatch $config.Exclude)) {
$caching = $false
}
if (($null -ne $config.Include) -and ($Path -inotmatch $config.Include)) {
$caching = $false
}
}
return $caching
}
function Get-PodeRouteByUrl
{
param (
[Parameter()]
[hashtable[]]
$Routes,
[Parameter()]
[string]
$EndpointName
)
# if routes is already null/empty just return
if (($null -eq $Routes) -or ($Routes.Length -eq 0)) {
return $null
}
# get the route
return (Get-PodeRoutesByUrl -Routes $Routes -EndpointName $EndpointName)
}
function Get-PodeRoutesByUrl
{
param (
[Parameter()]
[hashtable[]]
$Routes,
[Parameter()]
[string]
$EndpointName
)
# see if a route has the endpoint name
if (![string]::IsNullOrWhiteSpace($EndpointName)) {
foreach ($route in $Routes) {
if ($route.Endpoint.Name -ieq $EndpointName) {
return $route
}
}
}
# else find first default route
foreach ($route in $Routes) {
if ([string]::IsNullOrWhiteSpace($route.Endpoint.Name)) {
return $route
}
}
return $null
}
function Update-PodeRoutePlaceholders
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path
)
# replace placeholder parameters with regex
$placeholder = '\:(?<tag>[\w]+)'
if ($Path -imatch $placeholder) {
$Path = [regex]::Escape($Path)
}
while ($Path -imatch $placeholder) {
$Path = ($Path -ireplace $Matches[0], "(?<$($Matches['tag'])>[^\/]+?)")
}
return $Path
}
function ConvertTo-PodeOpenApiRoutePath
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path
)
# replace placeholder parameters with regex
$placeholder = '\:(?<tag>[\w]+)'
if ($Path -imatch $placeholder) {
$Path = [regex]::Escape($Path)
}
while ($Path -imatch $placeholder) {
$Path = ($Path -ireplace $Matches[0], "{$($Matches['tag'])}")
}
return $Path
}
function Update-PodeRouteSlashes
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path,
[switch]
$Static
)
# ensure route starts with a '/'
if (!$Path.StartsWith('/')) {
$Path = "/$($Path)"
}
if ($Static) {
# ensure the static route ends with '/{0,1}.*'
$Path = $Path.TrimEnd('/*')
$Path = "$($Path)[/]{0,1}(?<file>*)"
}
# replace * with .*
$Path = ($Path -ireplace '\*', '.*')
return $Path
}
function Split-PodeRouteQuery
{
param (
[Parameter(Mandatory=$true)]
[string]
$Path
)
return ($Path -isplit "\?")[0]
}
function ConvertTo-PodeRouteRegex
{
param (
[Parameter()]
[string]
$Path
)
if ([string]::IsNullOrWhiteSpace($Path)) {
return [string]::Empty
}
$Path = Protect-PodeValue -Value $Path -Default '/'
$Path = Split-PodeRouteQuery -Path $Path
$Path = Protect-PodeValue -Value $Path -Default '/'
$Path = Update-PodeRouteSlashes -Path $Path
$Path = Update-PodeRoutePlaceholders -Path $Path
return $Path
}
function Get-PodeStaticRouteDefaults
{
if (!(Test-PodeIsEmpty $PodeContext.Server.Web.Static.Defaults)) {
return @($PodeContext.Server.Web.Static.Defaults)
}
return @(
'index.html',
'index.htm',
'default.html',
'default.htm'
)
}
function Test-PodeRouteAndError
{
param (
[Parameter(Mandatory=$true)]
[string]
$Method,
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[string]
$Protocol,
[Parameter()]
[string]
$Address
)
$found = @($PodeContext.Server.Routes[$Method][$Path])
if (($found | Where-Object { ($_.Endpoint.Protocol -ieq $Protocol) -and ($_.Endpoint.Address -ieq $Address) } | Measure-Object).Count -eq 0) {
return
}
$_url = $Protocol
if (![string]::IsNullOrEmpty($_url) -and ![string]::IsNullOrWhiteSpace($Address)) {
$_url = "$($_url)://$($Address)"
}
elseif (![string]::IsNullOrWhiteSpace($Address)) {
$_url = $Address
}
if ([string]::IsNullOrEmpty($_url)) {
throw "[$($Method)] $($Path): Already defined"
}
else {
throw "[$($Method)] $($Path): Already defined for $($_url)"
}
}
function Convert-PodeFunctionVerbToHttpMethod
{
param (
[Parameter()]
[string]
$Verb
)
# if empty, just return default
switch ($Verb) {
{ $_ -iin @('Find', 'Format', 'Get', 'Join', 'Search', 'Select', 'Split', 'Measure', 'Ping', 'Test', 'Trace') } { 'GET' }
{ $_ -iin @('Set') } { 'PUT' }
{ $_ -iin @('Rename', 'Edit', 'Update') } { 'PATCH' }
{ $_ -iin @('Clear', 'Close', 'Exit', 'Hide', 'Remove', 'Undo', 'Dismount', 'Unpublish', 'Disable', 'Uninstall', 'Unregister') } { 'DELETE' }
Default { 'POST' }
}
}
function Find-PodeRouteTransferEncoding
{
param(
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[string]
$TransferEncoding
)
# if we already have one, return it
if (![string]::IsNullOrWhiteSpace($TransferEncoding)) {
return $TransferEncoding
}
# set the default
$TransferEncoding = $PodeContext.Server.Web.TransferEncoding.Default
# find type by pattern from settings
$matched = ($PodeContext.Server.Web.TransferEncoding.Routes.Keys | Where-Object {
$Path -imatch $_
} | Select-Object -First 1)
# if we get a match, set it
if (!(Test-PodeIsEmpty $matched)) {
$TransferEncoding = $PodeContext.Server.Web.TransferEncoding.Routes[$matched]
}
return $TransferEncoding
}
function Find-PodeRouteContentType
{
param(
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[string]
$ContentType
)
# if we already have one, return it
if (![string]::IsNullOrWhiteSpace($ContentType)) {
return $ContentType
}
# set the default
$ContentType = $PodeContext.Server.Web.ContentType.Default
# find type by pattern from settings
$matched = ($PodeContext.Server.Web.ContentType.Routes.Keys | Where-Object {
$Path -imatch $_
} | Select-Object -First 1)
# if we get a match, set it
if (!(Test-PodeIsEmpty $matched)) {
$ContentType = $PodeContext.Server.Web.ContentType.Routes[$matched]
}
return $ContentType
}
function ConvertTo-PodeRouteMiddleware
{
[OutputType([hashtable[]])]
param(
[Parameter(Mandatory=$true)]
[string]
$Method,
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[object[]]
$Middleware,
[Parameter(Mandatory=$true)]
[System.Management.Automation.SessionState]
$PSSession
)
# return if no middleware
if (Test-PodeIsEmpty $Middleware) {
return $null
}
# ensure supplied middlewares are either a scriptblock, or a valid hashtable
@($Middleware) | ForEach-Object {
# check middleware is a type valid
if (($_ -isnot [scriptblock]) -and ($_ -isnot [hashtable])) {
throw "One of the Route Middlewares supplied for the '[$($Method)] $($Path)' Route is an invalid type. Expected either ScriptBlock or Hashtable, but got: $($_.GetType().Name)"
}
# if middleware is hashtable, ensure the keys are valid (logic is a scriptblock)
if ($_ -is [hashtable]) {
if ($null -eq $_.Logic) {
throw "A Hashtable Middleware supplied for the '[$($Method)] $($Path)' Route has no Logic defined"
}
if ($_.Logic -isnot [scriptblock]) {
throw "A Hashtable Middleware supplied for the '[$($Method)] $($Path)' Route has an invalid Logic type. Expected ScriptBlock, but got: $($_.Logic.GetType().Name)"
}
}
}
# if we have middleware, convert scriptblocks to hashtables
$Middleware = @($Middleware)
for ($i = 0; $i -lt $Middleware.Length; $i++) {
if ($Middleware[$i] -is [scriptblock]) {
$_script, $_usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $Middleware[$i] -PSSession $PSSession
$Middleware[$i] = @{
Logic = $_script
UsingVariables = $_usingVars
}
}
}
return $Middleware
}
function Find-PodeSchedule
{
param(
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Name
)
return $PodeContext.Schedules[$Name]
}
function Start-PodeScheduleRunspace
{
if ((Get-PodeCount $PodeContext.Schedules) -eq 0) {
return
}
$script = {
# select the schedules that trigger on-start
$_now = [DateTime]::Now
$PodeContext.Schedules.Values |
Where-Object {
$_.OnStart
} | ForEach-Object {
Invoke-PodeInternalSchedule -Schedule $_
}
# complete any schedules
Complete-PodeInternalSchedules -Now $_now
# first, sleep for a period of time to get to 00 seconds (start of minute)
Start-Sleep -Seconds (60 - [DateTime]::Now.Second)
while ($true)
{
$_now = [DateTime]::Now
# select the schedules that need triggering
$PodeContext.Schedules.Values |
Where-Object {
!$_.Completed -and
(($null -eq $_.StartTime) -or ($_.StartTime -le $_now)) -and
(($null -eq $_.EndTime) -or ($_.EndTime -ge $_now)) -and
(Test-PodeCronExpressions -Expressions $_.Crons -DateTime $_now)
} | ForEach-Object {
Invoke-PodeInternalSchedule -Schedule $_
}
# complete any schedules
Complete-PodeInternalSchedules -Now $_now
# cron expression only goes down to the minute, so sleep for 1min
Start-Sleep -Seconds (60 - [DateTime]::Now.Second)
}
}
Add-PodeRunspace -Type Main -ScriptBlock $script
}
function Complete-PodeInternalSchedules
{
param(
[Parameter(Mandatory=$true)]
[datetime]
$Now
)
# add any schedules to remove that have exceeded their end time
$Schedules = @($PodeContext.Schedules.Values |
Where-Object { (($null -ne $_.EndTime) -and ($_.EndTime -lt $Now)) })
if (($null -eq $Schedules) -or ($Schedules.Length -eq 0)) {
return
}
# set any expired schedules as being completed
$Schedules | ForEach-Object {
$_.Completed = $true
}
}
function Invoke-PodeInternalSchedule
{
param(
[Parameter(Mandatory=$true)]
$Schedule
)
$Schedule.OnStart = $false
# increment total number of triggers for the schedule
$Schedule.Count++
# check if we have hit the limit, and remove
if (($Schedule.Limit -gt 0) -and ($Schedule.Count -ge $Schedule.Limit)) {
$Schedule.Completed = $true
}
# trigger the schedules logic
Invoke-PodeInternalScheduleLogic -Schedule $Schedule
# reset the cron if it's random
if (!$Schedule.Completed) {
$Schedule.Crons = Reset-PodeRandomCronExpressions -Expressions $Schedule.Crons
$Schedule.NextTriggerTime = Get-PodeCronNextEarliestTrigger -Expressions $Schedule.Crons -EndTime $Schedule.EndTime
}
else {
$Schedule.NextTriggerTime = $null
}
}
function Invoke-PodeInternalScheduleLogic
{
param(
[Parameter(Mandatory=$true)]
$Schedule
)
try {
# setup event param
$parameters = @{
Event = @{
Lockable = $PodeContext.Lockable
}
}
# add any custom args as params
foreach ($key in $Schedule.Arguments.Keys) {
$parameters[$key] = $Schedule.Arguments[$key]
}
# add any using variables as params
if ($null -ne $Schedule.UsingVariables) {
foreach ($usingVar in $Schedule.UsingVariables) {
$parameters[$usingVar.NewName] = $usingVar.Value
}
}
Add-PodeRunspace -Type Schedules -ScriptBlock (($Schedule.Script).GetNewClosure()) -Parameters $parameters -Forget
}
catch {
$_ | Write-PodeErrorLog
}
}
using namespace System.Security.Cryptography
function Test-PodeIPLimit
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$IP
)
$type = 'IP'
# get the limit rules and active list
$rules = $PodeContext.Server.Limits.Rules[$type]
$active = $PodeContext.Server.Limits.Active[$type]
# if there are no rules, it's valid
if (($null -eq $rules) -or ($rules.Count -eq 0)) {
return $true
}
# get the ip address in bytes
$IP = @{
String = $IP.IPAddressToString
Family = $IP.AddressFamily
Bytes = $IP.GetAddressBytes()
}
# now
$now = [DateTime]::UtcNow
# is the ip active? (get a direct match, then try grouped subnets)
$_active_ip = $active[$IP.String]
if ($null -eq $_active_ip) {
$_groups = @(foreach ($key in $active.Keys) {
if ($active[$key].Rule.Grouped) {
$active[$key]
}
})
$_active_ip = @(foreach ($_group in $_groups) {
if (Test-PodeIPAddressInRange -IP $IP -LowerIP $_group.Rule.Lower -UpperIP $_group.Rule.Upper) {
$_group
break
}
})[0]
}
# the ip is active, or part of a grouped subnet
if ($null -ne $_active_ip) {
# if limit is -1, always allowed
if ($_active_ip.Rule.Limit -eq -1) {
return $true
}
# check expire time, a reset if needed
if ($now -ge $_active_ip.Expire) {
$_active_ip.Rate = 0
$_active_ip.Expire = $now.AddSeconds($_active_ip.Rule.Seconds)
}
# are we over the limit?
if ($_active_ip.Rate -ge $_active_ip.Rule.Limit) {
return $false
}
# increment the rate
$_active_ip.Rate++
return $true
}
# the ip isn't active
else {
# get the ip's rule
$_rule_ip = @(foreach ($rule in $rules.Values) {
if (Test-PodeIPAddressInRange -IP $IP -LowerIP $rule.Lower -UpperIP $rule.Upper) {
$rule
break
}
})[0]
# if ip not in rules, it's valid
# (add to active list as always allowed - saves running where search everytime)
if ($null -eq $_rule_ip) {
$active.Add($IP.String, @{
Rule = @{
Limit = -1
}
})
return $true
}
# add ip to active list (ip if not grouped, else the subnet if it's grouped)
$_ip = (Resolve-PodeValue -Check $_rule_ip.Grouped -TrueValue $_rule_ip.IP -FalseValue $IP.String)
$active.Add($_ip, @{
Rule = $_rule_ip
Rate = 1
Expire = $now.AddSeconds($_rule_ip.Seconds)
})
# if limit is 0, it's never allowed
return ($_rule_ip -ne 0)
}
}
function Test-PodeRouteLimit
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[string]
$Path
)
$type = 'Route'
# get the limit rules and active list
$rules = $PodeContext.Server.Limits.Rules[$type]
$active = $PodeContext.Server.Limits.Active[$type]
# if there are no rules, it's valid
if (($null -eq $rules) -or ($rules.Count -eq 0)) {
return $true
}
# now
$now = [DateTime]::UtcNow
# is the route active?
$_active_route = $active[$Path]
# the ip is active, or part of a grouped subnet
if ($null -ne $_active_route) {
# if limit is -1, always allowed
if ($_active_route.Rule.Limit -eq -1) {
return $true
}
# check expire time, a reset if needed
if ($now -ge $_active_route.Expire) {
$_active_route.Rate = 0
$_active_route.Expire = $now.AddSeconds($_active_route.Rule.Seconds)
}
# are we over the limit?
if ($_active_route.Rate -ge $_active_route.Rule.Limit) {
return $false
}
# increment the rate
$_active_route.Rate++
return $true
}
# the route isn't active
else {
# get the route's rule
$_rule_route = $rules[$Path]
# if route not in rules, it's valid (add to active list as always allowed)
if ($null -eq $_rule_route) {
$active.Add($Path, @{
Rule = @{
Limit = -1
}
})
return $true
}
# add route to active list
$active.Add($Path, @{
Rule = $_rule_route
Rate = 1
Expire = $now.AddSeconds($_rule_route.Seconds)
})
# if limit is 0, it's never allowed
return ($_rule_route -ne 0)
}
}
function Test-PodeEndpointLimit
{
param (
[Parameter()]
[string]
$EndpointName
)
$type = 'Endpoint'
if ([string]::IsNullOrWhiteSpace($EndpointName)) {
return $true
}
# get the limit rules and active list
$rules = $PodeContext.Server.Limits.Rules[$type]
$active = $PodeContext.Server.Limits.Active[$type]
# if there are no rules, it's valid
if (($null -eq $rules) -or ($rules.Count -eq 0)) {
return $true
}
# now
$now = [DateTime]::UtcNow
# is the endpoint active?
$_active_endpoint = $active[$EndpointName]
# the endpoint is active
if ($null -ne $_active_endpoint) {
# if limit is -1, always allowed
if ($_active_endpoint.Rule.Limit -eq -1) {
return $true
}
# check expire time, a reset if needed
if ($now -ge $_active_endpoint.Expire) {
$_active_endpoint.Rate = 0
$_active_endpoint.Expire = $now.AddSeconds($_active_endpoint.Rule.Seconds)
}
# are we over the limit?
if ($_active_endpoint.Rate -ge $_active_endpoint.Rule.Limit) {
return $false
}
# increment the rate
$_active_endpoint.Rate++
return $true
}
# the endpoint isn't active
else {
# get the endpoint's rule
$_rule_endpoint = $rules[$EndpointName]
# if endpoint not in rules, it's valid (add to active list as always allowed)
if ($null -eq $_rule_endpoint) {
$active.Add($EndpointName, @{
Rule = @{
Limit = -1
}
})
return $true
}
# add endpoint to active list
$active.Add($EndpointName, @{
Rule = $_rule_endpoint
Rate = 1
Expire = $now.AddSeconds($_rule_endpoint.Seconds)
})
# if limit is 0, it's never allowed
return ($_rule_endpoint -ne 0)
}
}
function Test-PodeIPAccess
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$IP
)
$type = 'IP'
# get permission lists for ip
$allow = $PodeContext.Server.Access.Allow[$type]
$deny = $PodeContext.Server.Access.Deny[$type]
# are they empty?
$alEmpty = (($null -eq $allow) -or ($allow.Count -eq 0))
$dnEmpty = (($null -eq $deny) -or ($deny.Count -eq 0))
# if both are empty, value is valid
if ($alEmpty -and $dnEmpty) {
return $true
}
# get the ip address in bytes
$IP = @{
Family = $IP.AddressFamily
Bytes = $IP.GetAddressBytes()
}
# if value in allow, it's allowed
if (!$alEmpty) {
$match = @(foreach ($value in $allow.Values) {
if (Test-PodeIPAddressInRange -IP $IP -LowerIP $value.Lower -UpperIP $value.Upper) {
$value
break
}
})[0]
if ($null -ne $match) {
return $true
}
}
# if value in deny, it's disallowed
if (!$dnEmpty) {
$match = @(foreach ($value in $deny.Values) {
if (Test-PodeIPAddressInRange -IP $IP -LowerIP $value.Lower -UpperIP $value.Upper) {
$value
break
}
})[0]
if ($null -ne $match) {
return $false
}
}
# if we have an allow, it's disallowed (because it's not in there)
if (!$alEmpty) {
return $false
}
# otherwise it's allowed (because it's not in the deny)
return $true
}
function Add-PodeIPLimit
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[string]
$IP,
[Parameter(Mandatory=$true)]
[int]
$Limit,
[Parameter(Mandatory=$true)]
[int]
$Seconds,
[switch]
$Group
)
# current limit type
$type = 'IP'
# ensure limit and seconds are non-zero and negative
if ($Limit -le 0) {
throw "Limit value cannot be 0 or less for $($IP)"
}
if ($Seconds -le 0) {
throw "Seconds value cannot be 0 or less for $($IP)"
}
# get current rules
$rules = $PodeContext.Server.Limits.Rules[$type]
# setup up perm type
if ($null -eq $rules) {
$PodeContext.Server.Limits.Rules[$type] = @{}
$PodeContext.Server.Limits.Active[$type] = @{}
$rules = $PodeContext.Server.Limits.Rules[$type]
}
# have we already added the ip?
elseif ($rules.ContainsKey($IP)) {
return
}
# calculate the lower/upper ip bounds
if (Test-PodeIPAddressIsSubnetMask -IP $IP) {
$_tmp = Get-PodeSubnetRange -SubnetMask $IP
$_tmpLo = Get-PodeIPAddress -IP $_tmp.Lower
$_tmpHi = Get-PodeIPAddress -IP $_tmp.Upper
}
elseif (Test-PodeIPAddressAny -IP $IP) {
$_tmpLo = Get-PodeIPAddress -IP '0.0.0.0'
$_tmpHi = Get-PodeIPAddress -IP '255.255.255.255'
}
else {
$_tmpLo = Get-PodeIPAddress -IP $IP
$_tmpHi = $_tmpLo
}
# add limit rule for ip
$rules.Add($IP, @{
Limit = $Limit
Seconds = $Seconds
Grouped = [bool]$Group
IP = $IP
Lower = @{
Family = $_tmpLo.AddressFamily
Bytes = $_tmpLo.GetAddressBytes()
}
Upper = @{
Family = $_tmpHi.AddressFamily
Bytes = $_tmpHi.GetAddressBytes()
}
})
}
function Add-PodeRouteLimit
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[string]
$Path,
[Parameter(Mandatory=$true)]
[int]
$Limit,
[Parameter(Mandatory=$true)]
[int]
$Seconds,
[switch]
$Group
)
# current limit type
$type = 'Route'
# ensure limit and seconds are non-zero and negative
if ($Limit -le 0) {
throw "Limit value cannot be 0 or less for $($IP)"
}
if ($Seconds -le 0) {
throw "Seconds value cannot be 0 or less for $($IP)"
}
# get current rules
$rules = $PodeContext.Server.Limits.Rules[$type]
# setup up perm type
if ($null -eq $rules) {
$PodeContext.Server.Limits.Rules[$type] = @{}
$PodeContext.Server.Limits.Active[$type] = @{}
$rules = $PodeContext.Server.Limits.Rules[$type]
}
# have we already added the route?
elseif ($rules.ContainsKey($Path)) {
return
}
# add limit rule for the route
$rules.Add($Path, @{
Limit = $Limit
Seconds = $Seconds
Grouped = [bool]$Group
Path = $Path
})
}
function Add-PodeEndpointLimit
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[string]
$EndpointName,
[Parameter(Mandatory=$true)]
[int]
$Limit,
[Parameter(Mandatory=$true)]
[int]
$Seconds,
[switch]
$Group
)
# current limit type
$type = 'Endpoint'
# ensure limit and seconds are non-zero and negative
if ($Limit -le 0) {
throw "Limit value cannot be 0 or less for $($IP)"
}
if ($Seconds -le 0) {
throw "Seconds value cannot be 0 or less for $($IP)"
}
# we need to check endpoints on requests
$PodeContext.Server.FindRouteEndpoint = $true
# get current rules
$rules = $PodeContext.Server.Limits.Rules[$type]
# setup up perm type
if ($null -eq $rules) {
$PodeContext.Server.Limits.Rules[$type] = @{}
$PodeContext.Server.Limits.Active[$type] = @{}
$rules = $PodeContext.Server.Limits.Rules[$type]
}
# have we already added the endpoint?
elseif ($rules.ContainsKey($EndpointName)) {
return
}
# add limit rule for the endpoint
$rules.Add($EndpointName, @{
Limit = $Limit
Seconds = $Seconds
Grouped = [bool]$Group
EndpointName = $EndpointName
})
}
function Add-PodeIPAccess
{
param (
[Parameter(Mandatory=$true)]
[ValidateSet('Allow', 'Deny')]
[string]
$Access,
[Parameter(Mandatory=$true)]
[string]
$IP
)
# current access type
$type = 'IP'
# get opposite permission
$opp = "$(if ($Access -ieq 'allow') { 'Deny' } else { 'Allow' })"
# get permission lists for type
$permType = $PodeContext.Server.Access[$Access][$type]
$oppType = $PodeContext.Server.Access[$opp][$type]
# setup up perm type
if ($null -eq $permType) {
$PodeContext.Server.Access[$Access][$type] = @{}
$permType = $PodeContext.Server.Access[$Access][$type]
}
# have we already added the ip?
elseif ($permType.ContainsKey($IP)) {
return
}
# remove from opp type
if ($null -ne $oppType -and $oppType.ContainsKey($IP)) {
$oppType.Remove($IP)
}
# calculate the lower/upper ip bounds
if (Test-PodeIPAddressIsSubnetMask -IP $IP) {
$_tmp = Get-PodeSubnetRange -SubnetMask $IP
$_tmpLo = Get-PodeIPAddress -IP $_tmp.Lower
$_tmpHi = Get-PodeIPAddress -IP $_tmp.Upper
}
elseif (Test-PodeIPAddressAny -IP $IP) {
$_tmpLo = Get-PodeIPAddress -IP '0.0.0.0'
$_tmpHi = Get-PodeIPAddress -IP '255.255.255.255'
}
else {
$_tmpLo = Get-PodeIPAddress -IP $IP
$_tmpHi = $_tmpLo
}
# add access rule for ip
$permType.Add($IP, @{
Lower = @{
Family = $_tmpLo.AddressFamily
Bytes = $_tmpLo.GetAddressBytes()
}
Upper = @{
Family = $_tmpHi.AddressFamily
Bytes = $_tmpHi.GetAddressBytes()
}
})
}
function Get-PodeCsrfToken
{
# key name to search
$key = $PodeContext.Server.Cookies.Csrf.Name
# check the payload
if (!(Test-PodeIsEmpty $WebEvent.Data[$key])) {
return $WebEvent.Data[$key]
}
# check the query string
if (!(Test-PodeIsEmpty $WebEvent.Query[$key])) {
return $WebEvent.Query[$key]
}
# check the headers
$value = (Get-PodeHeader -Name $key)
if (!(Test-PodeIsEmpty $value)) {
return $value
}
return $null
}
function Test-PodeCsrfToken
{
param (
[Parameter()]
[string]
$Secret,
[Parameter()]
[string]
$Token
)
# if there's no token/secret, fail
if ((Test-PodeIsEmpty $Secret) -or (Test-PodeIsEmpty $Token)) {
return $false
}
# the token must start with "t:"
if (!$Token.StartsWith('t:')) {
return $false
}
# get the salt from the token
$_token = $Token.Substring(2)
$periodIndex = $_token.LastIndexOf('.')
if ($periodIndex -eq -1) {
return $false
}
$salt = $_token.Substring(0, $periodIndex)
# ensure the token is valid
if ((Restore-PodeCsrfToken -Secret $Secret -Salt $salt) -ne $Token) {
return $false
}
return $true
}
function New-PodeCsrfSecret
{
# see if there's already a secret in session/cookie
$secret = (Get-PodeCsrfSecret)
if (!(Test-PodeIsEmpty $secret)) {
return $secret
}
# otherwise, make a new secret and cache it
$secret = (New-PodeGuid -Secure -Length 16)
Set-PodeCsrfSecret -Secret $secret
return $secret
}
function Get-PodeCsrfSecret
{
# key name to get secret
$key = $PodeContext.Server.Cookies.Csrf.Name
# are we getting it from a cookie, or session?
if ($PodeContext.Server.Cookies.Csrf.UseCookies) {
return (Get-PodeCookie `
-Name $PodeContext.Server.Cookies.Csrf.Name `
-Secret $PodeContext.Server.Cookies.Csrf.Secret).Value
}
# on session
else {
return $WebEvent.Session.Data[$key]
}
}
function Set-PodeCsrfSecret
{
param (
[Parameter(Mandatory=$true)]
[string]
$Secret
)
# key name to set secret under
$key = $PodeContext.Server.Cookies.Csrf.Name
# are we setting this on a cookie, or session?
if ($PodeContext.Server.Cookies.Csrf.UseCookies) {
(Set-PodeCookie `
-Name $PodeContext.Server.Cookies.Csrf.Name `
-Value $Secret `
-Secret $PodeContext.Server.Cookies.Csrf.Secret) | Out-Null
}
# on session
else {
$WebEvent.Session.Data[$key] = $Secret
}
}
function Restore-PodeCsrfToken
{
param (
[Parameter(Mandatory=$true)]
[string]
$Secret,
[Parameter(Mandatory=$true)]
[string]
$Salt
)
return "t:$($Salt).$(Invoke-PodeSHA256Hash -Value "$($Salt)-$($Secret)")"
}
function Test-PodeCsrfConfigured
{
return (!(Test-PodeIsEmpty $PodeContext.Server.Cookies.Csrf))
}
function Get-PodeCertificateByFile
{
param(
[Parameter(Mandatory=$true)]
[string]
$Certificate,
[Parameter()]
[string]
$Password = $null
)
$path = Get-PodeRelativePath -Path $Certificate -JoinRoot -Resolve
$cert = $null
if ([string]::IsNullOrWhiteSpace($Password)) {
$cert = [X509Certificates.X509Certificate2]::new($path)
}
else {
$cert = [X509Certificates.X509Certificate2]::new($path, $Password)
}
return $cert
}
function Find-PodeCertificateInCertStore
{
param(
[Parameter(Mandatory=$true)]
[X509Certificates.X509FindType]
$FindType,
[Parameter(Mandatory=$true)]
[string]
$Query,
[Parameter(Mandatory=$true)]
[X509Certificates.StoreName]
$StoreName,
[Parameter(Mandatory=$true)]
[X509Certificates.StoreLocation]
$StoreLocation
)
# fail if not windows
if (!(Test-PodeIsWindows)) {
throw "Certificate Thumbprints/Name are only supported on Windows"
}
# open the currentuser\my store
$x509store = [X509Certificates.X509Store]::new($StoreName, $StoreLocation)
try {
# attempt to find the cert
$x509store.Open([X509Certificates.OpenFlags]::ReadOnly)
$x509certs = $x509store.Certificates.Find($FindType, $Query, $false)
}
finally {
# close the store!
if ($null -ne $x509store) {
Close-PodeDisposable -Disposable $x509store -Close
}
}
# fail if no cert found for query
if (($null -eq $x509certs) -or ($x509certs.Count -eq 0)) {
throw "No certificate could be found in $($StoreLocation)\$($StoreName) for '$($Query)'"
}
return ([X509Certificates.X509Certificate2]($x509certs[0]))
}
function Get-PodeCertificateByThumbprint
{
param(
[Parameter(Mandatory=$true)]
[string]
$Thumbprint,
[Parameter(Mandatory=$true)]
[X509Certificates.StoreName]
$StoreName,
[Parameter(Mandatory=$true)]
[X509Certificates.StoreLocation]
$StoreLocation
)
return (Find-PodeCertificateInCertStore `
-FindType ([X509Certificates.X509FindType]::FindByThumbprint) `
-Query $Thumbprint `
-StoreName $StoreName `
-StoreLocation $StoreLocation)
}
function Get-PodeCertificateByName
{
param(
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true)]
[X509Certificates.StoreName]
$StoreName,
[Parameter(Mandatory=$true)]
[X509Certificates.StoreLocation]
$StoreLocation
)
return (Find-PodeCertificateInCertStore `
-FindType ([X509Certificates.X509FindType]::FindBySubjectName) `
-Query $Name `
-StoreName $StoreName `
-StoreLocation $StoreLocation)
}
function New-PodeSelfSignedCertificate
{
$sanBuilder = [X509Certificates.SubjectAlternativeNameBuilder]::new()
$sanBuilder.AddIpAddress([ipaddress]::Loopback) | Out-Null
$sanBuilder.AddIpAddress([ipaddress]::IPv6Loopback) | Out-Null
$sanBuilder.AddDnsName('localhost') | Out-Null
if (![string]::IsNullOrWhiteSpace($PodeContext.Server.ComputerName)) {
$sanBuilder.AddDnsName($PodeContext.Server.ComputerName) | Out-Null
}
$rsa = [RSA]::Create(2048)
$distinguishedName = [X500DistinguishedName]::new("CN=localhost")
$req = [X509Certificates.CertificateRequest]::new(
$distinguishedName,
$rsa,
[HashAlgorithmName]::SHA256,
[RSASignaturePadding]::Pkcs1
)
$flags = (
[X509Certificates.X509KeyUsageFlags]::DataEncipherment -bor
[X509Certificates.X509KeyUsageFlags]::KeyEncipherment -bor
[X509Certificates.X509KeyUsageFlags]::DigitalSignature
)
$req.CertificateExtensions.Add(
[X509Certificates.X509KeyUsageExtension]::new(
$flags,
$false
)
) | Out-Null
$oid = [OidCollection]::new()
$oid.Add([Oid]::new('1.3.6.1.5.5.7.3.1')) | Out-Null
$req.CertificateExtensions.Add(
[X509Certificates.X509EnhancedKeyUsageExtension]::new(
$oid,
$false
)
)
$req.CertificateExtensions.Add($sanBuilder.Build()) | Out-Null
$cert = $req.CreateSelfSigned(
[System.DateTimeOffset]::UtcNow.AddDays(-1),
[System.DateTimeOffset]::UtcNow.AddYears(10)
)
if (Test-PodeIsWindows) {
$cert.FriendlyName = 'localhost'
}
$cert = [X509Certificates.X509Certificate2]::new(
$cert.Export([X509Certificates.X509ContentType]::Pfx, 'self-signed'),
'self-signed'
)
return $cert
}
function Start-PodeInternalServer
{
param (
[Parameter()]
$Request,
[switch]
$Browse
)
try
{
# setup temp drives for internal dirs
Add-PodePSInbuiltDrives
# create the shared runspace state
New-PodeRunspaceState
# get the server's script and invoke it - to set up routes, timers, middleware, etc
$_script = $PodeContext.Server.Logic
if (Test-PodePath -Path $PodeContext.Server.LogicPath -NoStatus) {
$_script = Convert-PodeFileToScriptBlock -FilePath $PodeContext.Server.LogicPath
}
Invoke-PodeScriptBlock -ScriptBlock $_script -NoNewClosure
# load any modules/snapins
Import-PodeSnapinsIntoRunspaceState
Import-PodeModulesIntoRunspaceState
# load any functions
Import-PodeFunctionsIntoRunspaceState -ScriptBlock $_script
# start the runspace pools for web, schedules, etc
New-PodeRunspacePools
Open-PodeRunspacePools
# create timer/schedules for auto-restarting
New-PodeAutoRestartServer
if (!$PodeContext.Server.IsServerless -and ($PodeContext.Server.Types.Length -gt 0))
{
# start runspace for loggers
Start-PodeLoggingRunspace
# start runspace for timers
Start-PodeTimerRunspace
# start runspace for schedules
Start-PodeScheduleRunspace
# start runspace for gui
Start-PodeGuiRunspace
}
# start the appropriate server
$endpoints = @()
# - service
if ($PodeContext.Server.IsService) {
Start-PodeServiceServer
}
# - serverless
elseif ($PodeContext.Server.IsServerless) {
switch ($PodeContext.Server.ServerlessType.ToUpperInvariant())
{
'AZUREFUNCTIONS' {
Start-PodeAzFuncServer -Data $Request
}
'AWSLAMBDA' {
Start-PodeAwsLambdaServer -Data $Request
}
}
}
# - normal
else {
foreach ($_type in $PodeContext.Server.Types) {
switch ($_type.ToUpperInvariant())
{
'SMTP' {
$endpoints += (Start-PodeSmtpServer)
}
'TCP' {
$endpoints += (Start-PodeTcpServer)
}
'HTTP' {
$endpoints += (Start-PodeWebServer -Browse:$Browse)
}
'WS' {
$endpoints += (Start-PodeSignalServer)
}
}
}
}
# set the start time of the server (start and after restart)
$PodeContext.Metrics.Server.StartTime = [datetime]::UtcNow
# state what endpoints are being listened on
if ($endpoints.Length -gt 0) {
Write-PodeHost "Listening on the following $($endpoints.Length) endpoint(s) [$($PodeContext.Threads.General) thread(s)]:" -ForegroundColor Yellow
$endpoints | ForEach-Object {
Write-PodeHost "`t- $($_)" -ForegroundColor Yellow
}
}
}
catch {
throw $_.Exception
}
}
function Restart-PodeInternalServer
{
try
{
# inform restart
Write-PodeHost 'Restarting server...' -NoNewline -ForegroundColor Cyan
# cancel the session token
$PodeContext.Tokens.Cancellation.Cancel()
# close all current runspaces
Close-PodeRunspaces -ClosePool
# remove all of the pode temp drives
Remove-PodePSDrives
# clear up timers, schedules and loggers
$PodeContext.Server.Routes.Keys.Clone() | ForEach-Object {
$PodeContext.Server.Routes[$_].Clear()
}
$PodeContext.Server.Handlers.Keys.Clone() | ForEach-Object {
$PodeContext.Server.Handlers[$_].Clear()
}
$PodeContext.Server.Views.Clear()
$PodeContext.Timers.Clear()
$PodeContext.Schedules.Clear()
$PodeContext.Server.Logging.Types.Clear()
# auto-importers
$PodeContext.Server.AutoImport.Modules.ExportList = @()
$PodeContext.Server.AutoImport.Snapins.ExportList = @()
$PodeContext.Server.AutoImport.Functions.ExportList = @()
# clear middle/endware
$PodeContext.Server.Middleware = @()
$PodeContext.Server.Endware = @()
# clear misc
$PodeContext.Server.BodyParsers.Clear()
# clear endpoints
$PodeContext.Server.Endpoints.Clear()
$PodeContext.Server.EndpointsMap.Clear()
$PodeContext.Server.FindRouteEndpoint = $false
# clear openapi
$PodeContext.Server.OpenAPI = Get-PodeOABaseObject
# clear the sockets
$PodeContext.Server.WebSockets.Listener = $null
$PodeContext.Listeners = @()
# set view engine back to default
$PodeContext.Server.ViewEngine = @{
Type = 'html'
Extension = 'html'
ScriptBlock = $null
UsingVariables = $null
IsDynamic = $false
}
# clear up cookie sessions
$PodeContext.Server.Sessions.Clear()
# clear up authentication methods
$PodeContext.Server.Authentications.Clear()
# clear up shared state
$PodeContext.Server.State.Clear()
# reset type if smtp/tcp
$PodeContext.Server.Types = @()
# recreate the session tokens
Close-PodeDisposable -Disposable $PodeContext.Tokens.Cancellation
$PodeContext.Tokens.Cancellation = New-Object System.Threading.CancellationTokenSource
Close-PodeDisposable -Disposable $PodeContext.Tokens.Restart
$PodeContext.Tokens.Restart = New-Object System.Threading.CancellationTokenSource
# reload the configuration
$PodeContext.Server.Configuration = Open-PodeConfiguration -Context $PodeContext
Write-PodeHost " Done" -ForegroundColor Green
# restart the server
$PodeContext.Metrics.Server.RestartCount++
Start-PodeInternalServer
}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
}
function Start-PodeAzFuncServer
{
param (
[Parameter(Mandatory=$true)]
$Data
)
# setup any inbuilt middleware that works for azure functions
$inbuilt_middleware = @(
(Get-PodePublicMiddleware),
(Get-PodeRouteValidateMiddleware),
(Get-PodeBodyMiddleware),
(Get-PodeCookieMiddleware)
)
$PodeContext.Server.Middleware = ($inbuilt_middleware + $PodeContext.Server.Middleware)
try
{
try
{
# get the request
$request = $Data.Request
# setup the response
$response = New-Object -TypeName HttpResponseContext
$response.StatusCode = 200
$response.Headers = @{}
# reset event data
$global:WebEvent = @{
OnEnd = @()
Auth = @{}
Response = $response
Request = $request
Lockable = $PodeContext.Lockable
Path = [string]::Empty
Method = $request.Method.ToLowerInvariant()
Query = $request.Query
Endpoint = @{
Protocol = ($request.Url -split '://')[0]
Address = $null
Name = $null
}
ContentType = $null
ErrorType = $null
Cookies = @{}
PendingCookies = @{}
Parameters = $null
Data = $null
Files = $null
Streamed = $false
Route = $null
StaticContent = $null
Timestamp = [datetime]::UtcNow
TransferEncoding = $null
AcceptEncoding = $null
}
$WebEvent.Endpoint.Address = ((Get-PodeHeader -Name 'host') -split ':')[0]
$WebEvent.ContentType = (Get-PodeHeader -Name 'content-type')
# set the path, using static content query parameter if passed
if (![string]::IsNullOrWhiteSpace($request.Query['static-file'])) {
$WebEvent.Path = $request.Query['static-file']
}
else {
$funcName = $Data.sys.MethodName
if ([string]::IsNullOrWhiteSpace($funcName)) {
$funcName = $Data.FunctionName
}
$WebEvent.Path = "/api/$($funcName)"
}
$WebEvent.Path = [System.Web.HttpUtility]::UrlDecode($WebEvent.Path)
# set pode in server response header
Set-PodeServerHeader -Type 'Kestrel'
# invoke global and route middleware
if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $PodeContext.Server.Middleware -Route $WebEvent.Path)) {
if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $WebEvent.Route.Middleware))
{
# invoke the route
if ($null -ne $WebEvent.StaticContent) {
if ($WebEvent.StaticContent.IsDownload) {
Set-PodeResponseAttachment -Path $WebEvent.Path -EndpointName $WebEvent.Endpoint.Name
}
else {
$cachable = $WebEvent.StaticContent.IsCachable
Write-PodeFileResponse -Path $WebEvent.StaticContent.Source -MaxAge $PodeContext.Server.Web.Static.Cache.MaxAge -Cache:$cachable
}
}
else {
$_args = @($WebEvent.Route.Arguments)
if ($null -ne $WebEvent.Route.UsingVariables) {
$_vars = @()
foreach ($_var in $WebEvent.Route.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
Invoke-PodeScriptBlock -ScriptBlock $WebEvent.Route.Logic -Arguments $_args -Scoped -Splat
}
}
}
}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
Set-PodeResponseStatus -Code 500 -Exception $_
}
finally {
Update-PodeServerRequestMetrics -WebEvent $WebEvent
}
# invoke endware specifc to the current web event
$_endware = ($WebEvent.OnEnd + @($PodeContext.Server.Endware))
Invoke-PodeEndware -WebEvent $WebEvent -Endware $_endware
# close and send the response
Push-OutputBinding -Name Response -Value $response
}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
}
function Start-PodeAwsLambdaServer
{
param (
[Parameter(Mandatory=$true)]
$Data
)
# setup any inbuilt middleware that works for aws lambda
$inbuilt_middleware = @(
(Get-PodePublicMiddleware),
(Get-PodeRouteValidateMiddleware),
(Get-PodeBodyMiddleware),
(Get-PodeCookieMiddleware)
)
$PodeContext.Server.Middleware = ($inbuilt_middleware + $PodeContext.Server.Middleware)
try
{
try
{
# get the request
$request = $Data
# setup the response
$response = @{
StatusCode = 200
Headers = @{}
Body = [string]::Empty
}
# reset event data
$global:WebEvent = @{
OnEnd = @()
Auth = @{}
Response = $response
Request = $request
Lockable = $PodeContext.Lockable
Path = [System.Web.HttpUtility]::UrlDecode($request.path)
Method = $request.httpMethod.ToLowerInvariant()
Query = $request.queryStringParameters
Endpoint = @{
Protocol = $null
Address = $null
Name = $null
}
ContentType = $null
ErrorType = $null
Cookies = @{}
PendingCookies = @{}
Parameters = $null
Data = $null
Files = $null
Streamed = $false
Route = $null
StaticContent = $null
Timestamp = [datetime]::UtcNow
TransferEncoding = $null
AcceptEncoding = $null
}
$WebEvent.Endpoint.Protocol = (Get-PodeHeader -Name 'X-Forwarded-Proto')
$WebEvent.Endpoint.Address = ((Get-PodeHeader -Name 'Host') -split ':')[0]
$WebEvent.ContentType = (Get-PodeHeader -Name 'Content-Type')
# set pode in server response header
Set-PodeServerHeader -Type 'Lambda'
# invoke global and route middleware
if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $PodeContext.Server.Middleware -Route $WebEvent.Path)) {
if ((Invoke-PodeMiddleware -WebEvent $WebEvent -Middleware $WebEvent.Route.Middleware))
{
# invoke the route
if ($null -ne $WebEvent.StaticContent) {
if ($WebEvent.StaticContent.IsDownload) {
Set-PodeResponseAttachment -Path $WebEvent.Path -EndpointName $WebEvent.Endpoint.Name
}
else {
$cachable = $WebEvent.StaticContent.IsCachable
Write-PodeFileResponse -Path $WebEvent.StaticContent.Source -MaxAge $PodeContext.Server.Web.Static.Cache.MaxAge -Cache:$cachable
}
}
else {
$_args = @($WebEvent.Route.Arguments)
if ($null -ne $WebEvent.Route.UsingVariables) {
$_vars = @()
foreach ($_var in $WebEvent.Route.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
Invoke-PodeScriptBlock -ScriptBlock $WebEvent.Route.Logic -Arguments $_args -Scoped -Splat
}
}
}
}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
Set-PodeResponseStatus -Code 500 -Exception $_
}
finally {
Update-PodeServerRequestMetrics -WebEvent $WebEvent
}
# invoke endware specifc to the current web event
$_endware = ($WebEvent.OnEnd + @($PodeContext.Server.Endware))
Invoke-PodeEndware -WebEvent $WebEvent -Endware $_endware
# close and send the response
if (![string]::IsNullOrWhiteSpace($response.ContentType)) {
Set-PodeHeader -Name 'Content-Type' -Value $response.ContentType
}
return (@{
'statusCode' = $response.StatusCode;
'headers' = $response.Headers;
'body' = $response.Body;
} | ConvertTo-Json -Depth 10 -Compress)
}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
}
function Start-PodeServiceServer
{
# ensure we have service handlers
if (Test-PodeIsEmpty (Get-PodeHandler -Type Service)) {
throw 'No Service handlers have been defined'
}
# state we're running
Write-PodeHost "Server looping every $($PodeContext.Server.Interval)secs" -ForegroundColor Yellow
# script for the looping server
$serverScript = {
try
{
while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)
{
# the event object
$ServiceEvent = @{
Lockable = $PodeContext.Lockable
}
# invoke the service handlers
$handlers = Get-PodeHandler -Type Service
foreach ($name in $handlers.Keys) {
$handler = $handlers[$name]
$_args = @($handler.Arguments)
if ($null -ne $handler.UsingVariables) {
$_vars = @()
foreach ($_var in $handler.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
Invoke-PodeScriptBlock -ScriptBlock $handler.Logic -Arguments $_args -Scoped -Splat
}
# sleep before next run
Start-Sleep -Seconds $PodeContext.Server.Interval
}
}
catch [System.OperationCanceledException] {}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
}
# start the runspace for the server
Add-PodeRunspace -Type Main -ScriptBlock $serverScript
}
function New-PodeSession
{
$sid = @{
Name = $PodeContext.Server.Sessions.Name
Id = (Invoke-PodeScriptBlock -ScriptBlock $PodeContext.Server.Sessions.GenerateId -Return)
Properties = $PodeContext.Server.Sessions.Info
Data = @{}
}
Set-PodeSessionDataHash -Session $sid
$sid.Properties.TimeStamp = [DateTime]::UtcNow
return $sid
}
function ConvertTo-PodeSessionStrictSecret
{
param(
[Parameter(Mandatory=$true)]
[string]
$Secret
)
return "$($Secret);$($WebEvent.Request.UserAgent);$($WebEvent.Request.RemoteEndPoint.Address.IPAddressToString)"
}
function Set-PodeSession
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[hashtable]
$Session
)
$secure = [bool]($Session.Properties.Secure)
$strict = [bool]($Session.Properties.Strict)
$discard = [bool]($Session.Properties.Discard)
$httpOnly = [bool]($Session.Properties.HttpOnly)
$useHeaders = [bool]($Session.Properties.UseHeaders)
$secret = $PodeContext.Server.Sessions.Secret
# covert secret to strict mode
if ($strict) {
$secret = ConvertTo-PodeSessionStrictSecret -Secret $secret
}
# set session on header
if ($useHeaders) {
Set-PodeHeader -Name $Session.Name -Value $Session.Id -Secret $secret
}
# set session as cookie
else {
(Set-PodeCookie `
-Name $Session.Name `
-Value $Session.Id `
-Secret $secret `
-ExpiryDate (Get-PodeSessionExpiry -Session $Session) `
-HttpOnly:$httpOnly `
-Discard:$discard `
-Secure:$secure) | Out-Null
}
}
function Get-PodeSession
{
param (
[Parameter(Mandatory=$true)]
[hashtable]
$Session
)
$secret = $Session.Secret
$timestamp = [datetime]::UtcNow
$value = $null
$name = $Session.Name
# covert secret to strict mode
if ($Session.Info.Strict) {
$secret = ConvertTo-PodeSessionStrictSecret -Secret $secret
}
# session from header
if ($Session.Info.UseHeaders) {
# check that the header is validly signed
if (!(Test-PodeHeaderSigned -Name $Session.Name -Secret $secret)) {
return $null
}
# get the header from the request
$value = Get-PodeHeader -Name $Session.Name -Secret $secret
if ([string]::IsNullOrWhiteSpace($value)) {
return $null
}
}
# session from cookie
else {
# check that the cookie is validly signed
if (!(Test-PodeCookieSigned -Name $Session.Name -Secret $secret)) {
return $null
}
# get the cookie from the request
$cookie = Get-PodeCookie -Name $Session.Name -Secret $secret
if ([string]::IsNullOrWhiteSpace($cookie)) {
return $null
}
# get details from cookie
$name = $cookie.Name
$value = $cookie.Value
$timestamp = $cookie.TimeStamp
}
# generate the session data
$data = @{
Name = $name
Id = $value
Properties = $Session.Info
Data = @{}
}
$data.Properties.TimeStamp = $timeStamp
return $data
}
function Revoke-PodeSession
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[hashtable]
$Session
)
# remove from cookie
if (!$Session.Properties.UseHeaders) {
Remove-PodeCookie -Name $Session.Name
}
# remove session from store
Invoke-PodeScriptBlock -ScriptBlock $Session.Delete -Arguments @($Session) -Splat
# blank the session
$Session.Clear()
}
function Set-PodeSessionDataHash
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[hashtable]
$Session
)
if (($null -eq $Session.Data) -or ($Session.Data.Count -eq 0)) {
$Session.Data = @{}
}
$Session.DataHash = (Invoke-PodeSHA256Hash -Value ($Session.Data | ConvertTo-Json -Depth 10 -Compress))
}
function Test-PodeSessionDataHash
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[hashtable]
$Session
)
if ([string]::IsNullOrWhiteSpace($Session.DataHash)) {
return $false
}
if (($null -eq $Session.Data) -or ($Session.Data.Count -eq 0)) {
$Session.Data = @{}
}
$hash = (Invoke-PodeSHA256Hash -Value ($Session.Data | ConvertTo-Json -Depth 10 -Compress))
return ($Session.DataHash -eq $hash)
}
function Get-PodeSessionExpiry
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[hashtable]
$Session
)
if ($null -eq $Session.Properties) {
return [DateTime]::MinValue
}
$expiry = [DateTime]::UtcNow
if (!([bool]$Session.Properties.Extend)) {
$expiry = $Session.Properties.TimeStamp
}
$expiry = $expiry.AddSeconds($Session.Properties.Duration)
return $expiry
}
function Set-PodeSessionHelpers
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
[hashtable]
$Session
)
# force save a session's data to the store
$Session | Add-Member -MemberType NoteProperty -Name Save -Value {
param($session, $check)
# do nothing if session has no ID
if ([string]::IsNullOrWhiteSpace($session.Id)) {
return
}
# only save if check and hashes different, but not if extending expiry
if (!$session.Properties.Extend -and $check -and (Test-PodeSessionDataHash -Session $session)) {
return
}
# generate the expiry
$expiry = (Get-PodeSessionExpiry -Session $session)
# save session data to store
Invoke-PodeScriptBlock -ScriptBlock $PodeContext.Server.Sessions.Store.Set -Arguments @($session.Id, $session.Data, $expiry) -Splat
# update session's data hash
Set-PodeSessionDataHash -Session $session
}
# delete the current session
$Session | Add-Member -MemberType NoteProperty -Name Delete -Value {
param($session)
# remove data from store
Invoke-PodeScriptBlock -ScriptBlock $PodeContext.Server.Sessions.Store.Delete -Arguments $session.Id
# clear session
$session.Clear()
}
}
function Get-PodeSessionInMemStore
{
$store = New-Object -TypeName psobject
# add in-mem storage
$store | Add-Member -MemberType NoteProperty -Name Memory -Value @{}
# delete a sessionId and data
$store | Add-Member -MemberType NoteProperty -Name Delete -Value {
param($sessionId)
$PodeContext.Server.Sessions.Store.Memory.Remove($sessionId) | Out-Null
}
# get a sessionId's data
$store | Add-Member -MemberType NoteProperty -Name Get -Value {
param($sessionId)
$s = $PodeContext.Server.Sessions.Store.Memory[$sessionId]
# if expire, remove
if (($null -ne $s) -and ($s.Expiry -lt [DateTime]::UtcNow)) {
$PodeContext.Server.Sessions.Store.Memory.Remove($sessionId) | Out-Null
return $null
}
return $s.Data
}
# update/insert a sessionId and data
$store | Add-Member -MemberType NoteProperty -Name Set -Value {
param($sessionId, $data, $expiry)
$PodeContext.Server.Sessions.Store.Memory[$sessionId] = @{
Data = $data
Expiry = $expiry
}
}
return $store
}
function Set-PodeSessionInMemClearDown
{
# don't setup if serverless - as memory is short lived anyway
if ($PodeContext.Server.IsServerless) {
return
}
# cleardown expired inmem session every 10 minutes
Add-PodeSchedule -Name '__pode_session_inmem_cleanup__' -Cron '0/10 * * * *' -ScriptBlock {
$store = $PodeContext.Server.Sessions.Store
if (Test-PodeIsEmpty $store.Memory) {
return
}
# remove sessions that have expired
$now = [DateTime]::UtcNow
foreach ($key in $store.Memory.Keys) {
if ($store.Memory[$key].Expiry -lt $now) {
$store.Memory.Remove($key)
}
}
}
}
function Test-PodeSessionsConfigured
{
return (($null -ne $PodeContext.Server.Sessions) -and ($PodeContext.Server.Sessions.Count -gt 0))
}
function Get-PodeSessionData
{
param(
[Parameter()]
[string]
$SessionId
)
return (Invoke-PodeScriptBlock -ScriptBlock $PodeContext.Server.Sessions.Store.Get -Arguments $SessionId -Return)
}
function Get-PodeSessionMiddleware
{
return {
# if session already set, return
if ($WebEvent.Session) {
return $true
}
try
{
# get the session from cookie/header
$WebEvent.Session = Get-PodeSession -Session $PodeContext.Server.Sessions
# if no session found, create a new one on the current web event
if (!$WebEvent.Session) {
$WebEvent.Session = (New-PodeSession)
$new = $true
}
# get the session's data
elseif ($null -ne ($data = (Get-PodeSessionData -SessionId $WebEvent.Session.Id))) {
$WebEvent.Session.Data = $data
Set-PodeSessionDataHash -Session $WebEvent.Session
}
# session not in store, create a new one
else {
$WebEvent.Session = (New-PodeSession)
$new = $true
}
# add helper methods to session
Set-PodeSessionHelpers -Session $WebEvent.Session
# add session to response if it's new or extendible
if ($new -or $WebEvent.Session.Properties.Extend) {
Set-PodeSession -Session $WebEvent.Session
}
# assign endware for session to set cookie/header
$WebEvent.OnEnd += @{
Logic = {
Save-PodeSession -Force
}
}
}
catch {
$_ | Write-PodeErrorLog
return $false
}
# move along
return $true
}
}
function Invoke-PodePackageScript
{
param (
[Parameter()]
[string]
$ActionScript
)
if ([string]::IsNullOrWhiteSpace($ActionScript)) {
return
}
Invoke-Expression -Command $ActionScript
}
function Install-PodeLocalModules
{
param (
[Parameter()]
$Modules = $null
)
if ($null -eq $Modules) {
return
}
$psModules = './ps_modules'
# download modules to ps_modules
$Modules.psobject.properties.name | ForEach-Object {
$_name = $_
# get the module version
$_version = $Modules.$_name.version
if ([string]::IsNullOrWhiteSpace($_version)) {
$_version = $Modules.$_name
}
# get the module repository
$_repository = Protect-PodeValue -Value $Modules.$_name.repository -Default 'PSGallery'
try {
# if version is latest, retrieve current
if ($_version -ieq 'latest') {
$_version = [string]((Find-Module $_name -Repository $_repository -ErrorAction Ignore).Version)
}
Write-Host "=> Downloading $($_name)@$($_version) from $($_repository)... " -NoNewline -ForegroundColor Cyan
# if the current version exists, do nothing
if (!(Test-Path (Join-Path $psModules "$($_name)/$($_version)"))) {
# remove other versions
if (Test-Path (Join-Path $psModules "$($_name)")) {
Remove-Item -Path (Join-Path $psModules "$($_name)") -Force -Recurse | Out-Null
}
# download the module
Save-Module -Name $_name -RequiredVersion $_version -Repository $_repository -Path $psModules -Force -ErrorAction Stop | Out-Null
}
Write-Host 'Success' -ForegroundColor Green
}
catch {
Write-Host 'Failed' -ForegroundColor Red
throw "Module or version not found on $($_repository): $($_name)@$($_version)"
}
}
}
using namespace Pode
function Start-PodeSignalServer
{
# work out which endpoints to listen on
$endpoints = @()
@(Get-PodeEndpoints -Type Ws) | ForEach-Object {
# get the ip address
$_ip = [string]($_.Address)
$_ip = (Get-PodeIPAddressesForHostname -Hostname $_ip -Type All | Select-Object -First 1)
$_ip = (Get-PodeIPAddress $_ip)
# add endpoint to list
$endpoints += @{
Address = $_ip
Hostname = $_.HostName
IsIPAddress = $_.IsIPAddress
Port = $_.Port
Certificate = $_.Certificate.Raw
AllowClientCertificate = $_.Certificate.AllowClientCertificate
Url = $_.Url
}
}
# create the listener
$listener = [PodeListener]::new($PodeContext.Tokens.Cancellation.Token, [PodeListenerType]::WebSocket)
$listener.ErrorLoggingEnabled = (Test-PodeErrorLoggingEnabled)
try
{
# register endpoints on the listener
$endpoints | ForEach-Object {
$socket = [PodeSocket]::new($_.Address, $_.Port, $PodeContext.Server.Sockets.Ssl.Protocols, $_.Certificate, $_.AllowClientCertificate)
$socket.ReceiveTimeout = $PodeContext.Server.Sockets.ReceiveTimeout
if (!$_.IsIPAddress) {
$socket.Hostnames.Add($_.HostName)
}
$listener.Add($socket)
}
$listener.Start()
$PodeContext.Listeners += $listener
$PodeContext.Server.WebSockets.Listener = $listener
}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
Close-PodeDisposable -Disposable $listener
throw $_.Exception
}
# script to write messages back to the client(s)
$signalScript = {
param(
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Listener
)
try {
while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested)
{
$message = (Wait-PodeTask -Task $Listener.GetServerSignalAsync($PodeContext.Tokens.Cancellation.Token))
# get the sockets for the message
$sockets = @()
# by clientId
if (![string]::IsNullOrWhiteSpace($message.ClientId)) {
$sockets = @($Listener.WebSockets[$message.ClientId])
}
else {
$sockets = @($Listener.WebSockets.Values)
# by path
if (![string]::IsNullOrWhiteSpace($message.Path)) {
$sockets = @(foreach ($socket in $sockets) {
if ($socket.Path -ieq $message.Path) {
$socket
break
}
})
}
}
# do nothing if no socket found
if (($null -eq $sockets) -or ($sockets.Length -eq 0)) {
continue
}
# send the message to all found sockets
foreach ($socket in $sockets) {
try {
$socket.Context.Response.SendSignal($message)
}
catch {
$Listener.WebSockets.Remove($socket.ClientId) | Out-Null
}
}
}
}
catch [System.OperationCanceledException] {}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
throw $_.Exception
}
}
Add-PodeRunspace -Type Signals -ScriptBlock $signalScript -Parameters @{ 'Listener' = $listener }
# script to queue messages from clients to send back to other clients from the server
$clientScript = {
param(
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Listener
)
try {
while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested)
{
$context = (Wait-PodeTask -Task $Listener.GetClientSignalAsync($PodeContext.Tokens.Cancellation.Token))
$context = ($context.Message | ConvertFrom-Json)
Send-PodeSignal -Value $context.message -Path $context.path -ClientId $context.clientId
}
}
catch [System.OperationCanceledException] {}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
throw $_.Exception
}
}
Add-PodeRunspace -Type Signals -ScriptBlock $clientScript -Parameters @{ 'Listener' = $listener }
# script to keep web server listening until cancelled
$waitScript = {
param(
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Listener
)
try {
while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested) {
Start-Sleep -Seconds 1
}
}
catch [System.OperationCanceledException] {}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
throw $_.Exception
}
finally {
Close-PodeDisposable -Disposable $Listener
}
}
Add-PodeRunspace -Type Signals -ScriptBlock $waitScript -Parameters @{ 'Listener' = $listener }
return @($endpoints.Url)
}
using namespace Pode
function Start-PodeSmtpServer
{
# ensure we have smtp handlers
if (Test-PodeIsEmpty (Get-PodeHandler -Type Smtp)) {
throw 'No SMTP handlers have been defined'
}
# the endpoint to listen on
$endpoint = @(Get-PodeEndpoints -Type Smtp)[0]
# grab the relavant port
$port = $endpoint.Port
# get the IP address for the server
$ipAddress = $endpoint.Address
if (Test-PodeHostname -Hostname $ipAddress) {
$ipAddress = (Get-PodeIPAddressesForHostname -Hostname $ipAddress -Type All | Select-Object -First 1)
$ipAddress = (Get-PodeIPAddress $ipAddress)
}
# create the listener
$listener = [PodeListener]::new($PodeContext.Tokens.Cancellation.Token, [PodeListenerType]::Smtp)
$listener.ErrorLoggingEnabled = (Test-PodeErrorLoggingEnabled)
try
{
# register endpoint on the listener
$socket = [PodeSocket]::new($ipAddress, $port, $PodeContext.Server.Sockets.Ssl.Protocols, $null)
$socket.ReceiveTimeout = $PodeContext.Server.Sockets.ReceiveTimeout
$socket.Hostnames.Add($endpoint.HostName)
$listener.Add($socket)
$listener.Start()
$PodeContext.Listeners += $listener
}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
Close-PodeDisposable -Disposable $listener
throw $_.Exception
}
# script for listening out of for incoming requests
$listenScript = {
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Listener,
[Parameter(Mandatory=$true)]
[int]
$ThreadId
)
try
{
while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested)
{
# get email
$context = (Wait-PodeTask -Task $Listener.GetContextAsync($PodeContext.Tokens.Cancellation.Token))
try
{
$Request = $context.Request
$Response = $context.Response
$SmtpEvent = @{
Response = $Response
Request = $Request
Lockable = $PodeContext.Lockable
Email = @{
From = $Request.From
To = $Request.To
Data = $Request.RawBody
Headers = $Request.Headers
Subject = $Request.Subject
IsUrgent = $Request.IsUrgent
ContentType = $Request.ContentType
ContentEncoding = $Request.ContentEncoding
Body = $Request.Body
}
}
# convert the ip
$ip = (ConvertTo-PodeIPAddress -Address $Request.RemoteEndPoint)
# ensure the request ip is allowed
if (!(Test-PodeIPAccess -IP $ip)) {
$Response.WriteLine('554 Your IP address was rejected', $true)
}
# has the ip hit the rate limit?
elseif (!(Test-PodeIPLimit -IP $ip)) {
$Response.WriteLine('554 Your IP address has hit the rate limit', $true)
}
# deal with smtp call
else {
$handlers = Get-PodeHandler -Type Smtp
foreach ($name in $handlers.Keys) {
$handler = $handlers[$name]
$_args = @($handler.Arguments)
if ($null -ne $handler.UsingVariables) {
$_vars = @()
foreach ($_var in $handler.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
Invoke-PodeScriptBlock -ScriptBlock $handler.Logic -Arguments $_args -Scoped -Splat
}
}
}
finally {
Close-PodeDisposable -Disposable $context
}
}
}
catch [System.OperationCanceledException] {}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
throw $_.Exception
}
}
# start the runspace for listening on x-number of threads
1..$PodeContext.Threads.General | ForEach-Object {
Add-PodeRunspace -Type Smtp -ScriptBlock $listenScript -Parameters @{ 'Listener' = $listener; 'ThreadId' = $_ }
}
# script to keep smtp server listening until cancelled
$waitScript = {
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Listener
)
try {
while ($Listener.IsListening -and !$PodeContext.Tokens.Cancellation.IsCancellationRequested) {
Start-Sleep -Seconds 1
}
}
catch [System.OperationCanceledException] {}
catch {
$_ | Write-PodeErrorLog
$_.Exception | Write-PodeErrorLog -CheckInnerException
throw $_.Exception
}
finally {
Close-PodeDisposable -Disposable $Listener
}
}
Add-PodeRunspace -Type Smtp -ScriptBlock $waitScript -Parameters @{ 'Listener' = $listener }
# state where we're running
return @("smtp://$($endpoint.FriendlyName):$($port)")
}
function Read-PodeStreamToEnd
{
param (
[Parameter()]
$Stream,
[Parameter()]
$Encoding = [System.Text.Encoding]::UTF8
)
if ($null -eq $Stream) {
return [string]::Empty
}
return (Use-PodeStream -Stream ([System.IO.StreamReader]::new($Stream, $Encoding)) {
return $args[0].ReadToEnd()
})
}
function Read-PodeByteLineFromByteArray
{
param (
[Parameter(Mandatory=$true)]
[byte[]]
$Bytes,
[Parameter()]
$Encoding = [System.Text.Encoding]::UTF8,
[Parameter()]
[int]
$StartIndex = 0,
[switch]
$IncludeNewLine
)
$nlBytes = Get-PodeNewLineBytes -Encoding $Encoding
# attempt to find \n
$index = [array]::IndexOf($Bytes, $nlBytes.NewLine, $StartIndex)
$fIndex = $index
# if not including new line, remove any trailing \r and \n
if (!$IncludeNewLine) {
$fIndex--
if ($Bytes[$fIndex] -eq $nlBytes.Return) {
$fIndex--
}
}
# grab the portion of the bytes array - which is our line
return @{
Bytes = $Bytes[$StartIndex..$fIndex];
StartIndex = $StartIndex;
EndIndex = $index;
}
}
function Get-PodeByteLinesFromByteArray
{
param (
[Parameter(Mandatory=$true)]
[byte[]]
$Bytes,
[Parameter()]
$Encoding = [System.Text.Encoding]::UTF8,
[switch]
$IncludeNewLine
)
# lines
$lines = @()
$nlBytes = Get-PodeNewLineBytes -Encoding $Encoding
# attempt to find \n
$index = 0
while (($nextIndex = [array]::IndexOf($Bytes, $nlBytes.NewLine, $index)) -gt 0) {
$fIndex = $nextIndex
# if not including new line, remove any trailing \r and \n
if (!$IncludeNewLine) {
$fIndex--
if ($Bytes[$fIndex] -eq $nlBytes.Return) {
$fIndex--
}
}
# add the line, and get the next one
$lines += ,$Bytes[$index..$fIndex]
$index = $nextIndex + 1
}
return $lines
}
function ConvertFrom-PodeStreamToBytes
{
param (
[Parameter(Mandatory=$true)]
$Stream
)
$buffer = [byte[]]::new(64 * 1024)
$ms = New-Object -TypeName System.IO.MemoryStream
$read = 0
while (($read = $Stream.Read($buffer, 0, $buffer.Length)) -gt 0) {
$ms.Write($buffer, 0, $read)
}
$ms.Close()
return $ms.ToArray()
}
function ConvertFrom-PodeValueToBytes
{
param (
[Parameter()]
[string]
$Value,
[Parameter()]
$Encoding = [System.Text.Encoding]::UTF8
)
return $Encoding.GetBytes($Value)
}
function ConvertFrom-PodeBytesToString
{
param (
[Parameter()]
[byte[]]
$Bytes,
[Parameter()]
$Encoding = [System.Text.Encoding]::UTF8,
[switch]
$RemoveNewLine
)
if (($null -eq $Bytes) -or ($Bytes.Length -eq 0)) {
return $Bytes
}
$value = $Encoding.GetString($Bytes)
if ($RemoveNewLine) {
$value = $value.Trim("`r`n")
}
return $value
}
function Get-PodeNewLineBytes
{
param (
[Parameter()]
$Encoding = [System.Text.Encoding]::UTF8
)
return @{
NewLine = @($Encoding.GetBytes("`n"))[0];
Return = @($Encoding.GetBytes("`r"))[0];
}
}
function Test-PodeByteArrayIsBoundary
{
param (
[Parameter()]
[byte[]]
$Bytes,
[Parameter()]
[string]
$Boundary,
[Parameter()]
$Encoding = [System.Text.Encoding]::UTF8
)
# if no bytes, return
if ($Bytes.Length -eq 0) {
return $false
}
# if length difference >3, return (ie, 2 offset for `r`n)
if (($Bytes.Length - $Boundary.Length) -gt 3) {
return $false
}
# check if bytes starts with the boundary
return (ConvertFrom-PodeBytesToString $Bytes $Encoding).StartsWith($Boundary)
}
function Remove-PodeNewLineBytesFromArray
{
param (
[Parameter()]
$Bytes,
[Parameter()]
$Encoding = [System.Text.Encoding]::UTF8
)
$nlBytes = Get-PodeNewLineBytes -Encoding $Encoding
$length = $Bytes.Length - 1
if ($Bytes[$length] -eq $nlBytes.NewLine) {
$length--
}
if ($Bytes[$length] -eq $nlBytes.Return) {
$length--
}
return $Bytes[0..$length]
}
function Start-PodeTcpServer
{
# ensure we have service handlers
if (Test-PodeIsEmpty (Get-PodeHandler -Type Tcp)) {
throw 'No TCP handlers have been defined'
}
# the endpoint to listen on
$endpoint = @(Get-PodeEndpoints -Type Tcp)[0]
# grab the relavant port
$port = $endpoint.Port
# get the IP address for the server
$ipAddress = $endpoint.Address
if (Test-PodeHostname -Hostname $ipAddress) {
$ipAddress = (Get-PodeIPAddressesForHostname -Hostname $ipAddress -Type All | Select-Object -First 1)
$ipAddress = (Get-PodeIPAddress $ipAddress)
}
try
{
# create the listener for tcp
$endpoint = New-Object System.Net.IPEndPoint($ipAddress, $port)
$listener = New-Object System.Net.Sockets.TcpListener -ArgumentList $endpoint
# start listener
$listener.Start()
}
catch {
if ($null -ne $listener) {
$listener.Stop()
}
throw $_.Exception
}
# script for listening out of for incoming requests
$listenScript = {
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Listener,
[Parameter(Mandatory=$true)]
[int]
$ThreadId
)
try
{
while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)
{
# get an incoming request
$client = (Wait-PodeTask -Task $Listener.AcceptTcpClientAsync())
# convert the ip
$ip = (ConvertTo-PodeIPAddress -Address $client.Client.RemoteEndPoint)
# ensure the request ip is allowed and deal with the tcp call
if ((Test-PodeIPAccess -IP $ip) -and (Test-PodeIPLimit -IP $ip)) {
$TcpEvent = @{
Client = $client
Lockable = $PodeContext.Lockable
}
# invoke the tcp handlers
$handlers = Get-PodeHandler -Type Tcp
foreach ($name in $handlers.Keys) {
$handler = $handlers[$name]
$_args = @($handler.Arguments)
if ($null -ne $handler.UsingVariables) {
$_vars = @()
foreach ($_var in $handler.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
Invoke-PodeScriptBlock -ScriptBlock $handler.Logic -Arguments $_args -Scoped -Splat
}
}
# close the connection
Close-PodeTcpConnection
}
}
catch [System.OperationCanceledException] {}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
}
# start the runspace for listening on x-number of threads
1..$PodeContext.Threads.General | ForEach-Object {
Add-PodeRunspace -Type Tcp -ScriptBlock $listenScript -Parameters @{ 'Listener' = $listener; 'ThreadId' = $_ }
}
# script to keep tcp server listening until cancelled
$waitScript = {
param (
[Parameter(Mandatory=$true)]
[ValidateNotNull()]
$Listener
)
try
{
while (!$PodeContext.Tokens.Cancellation.IsCancellationRequested)
{
Start-Sleep -Seconds 1
}
}
catch [System.OperationCanceledException] {}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
finally {
if ($null -ne $Listener) {
$Listener.Stop()
}
}
}
Add-PodeRunspace -Type Tcp -ScriptBlock $waitScript -Parameters @{ 'Listener' = $listener }
# state where we're running
return @("tcp://$($endpoint.FriendlyName):$($port)")
}
function Find-PodeTimer
{
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Name
)
return $PodeContext.Timers[$Name]
}
function Start-PodeTimerRunspace
{
if ((Get-PodeCount $PodeContext.Timers) -eq 0) {
return
}
$script = {
while ($true)
{
$_now = [DateTime]::Now
# only run timers that haven't completed, and have a next trigger in the past
$PodeContext.Timers.Values | Where-Object {
!$_.Completed -and ($_.OnStart -or ($_.NextTriggerTime -le $_now))
} | ForEach-Object {
$_.OnStart = $false
$_.Count++
# has the timer completed?
if (($_.Limit -gt 0) -and ($_.Count -ge $_.Limit)) {
$_.Completed = $true
}
# run the timer
Invoke-PodeInternalTimer -Timer $_
# next trigger
if (!$_.Completed) {
$_.NextTriggerTime = $_now.AddSeconds($_.Interval)
}
else {
$_.NextTriggerTime = $null
}
}
Start-Sleep -Seconds 1
}
}
Add-PodeRunspace -Type Main -ScriptBlock $script
}
function Invoke-PodeInternalTimer
{
param(
[Parameter(Mandatory=$true)]
$Timer
)
try {
$TimerEvent = @{ Lockable = $PodeContext.Lockable }
$_args = @($Timer.Arguments)
if ($null -ne $Timer.UsingVariables) {
$_vars = @()
foreach ($_var in $Timer.UsingVariables) {
$_vars += ,$_var.Value
}
$_args = $_vars + $_args
}
Invoke-PodeScriptBlock -ScriptBlock $Timer.Script -Arguments $_args -Scoped -Splat
}
catch {
$_ | Write-PodeErrorLog
}
}
<#
.SYNOPSIS
Create a new type of Authentication.
.DESCRIPTION
Create a new type of Authentication, which is used to parse the Request for user credentials for validating.
.PARAMETER Basic
If supplied, will use the inbuilt Basic Authentication credentials retriever.
.PARAMETER Encoding
The Encoding to use when decoding the Basic Authorization header.
.PARAMETER HeaderTag
The name of the type of Basic Authentication.
.PARAMETER Form
If supplied, will use the inbuilt Form Authentication credentials retriever.
.PARAMETER UsernameField
The name of the Username Field in the payload to retrieve the username.
.PARAMETER PasswordField
The name of the Password Field in the payload to retrieve the password.
.PARAMETER Custom
If supplied, will allow you to create a Custom Authentication credentials retriever.
.PARAMETER ScriptBlock
The ScriptBlock is used to parse the request and retieve user credentials and other information.
.PARAMETER ArgumentList
An array of arguments to supply to the Custom Authentication type's ScriptBlock.
.PARAMETER Name
The Name of an Authentication type - such as Basic or NTLM.
.PARAMETER Realm
The name of scope of the protected area.
.PARAMETER Type
The scheme type for custom Authentication types. Default is HTTP.
.PARAMETER PostValidator
The PostValidator is a scriptblock that is invoked after user validation.
.PARAMETER Digest
If supplied, will use the inbuilt Digest Authentication credentials retriever.
.PARAMETER Bearer
If supplied, will use the inbuilt Bearer Authentication token retriever.
.PARAMETER ClientCertificate
If supplied, will use the inbuilt Client Certificate Authentication scheme.
.PARAMETER ClientId
The Application ID generated when registering a new app for OAuth2.
.PARAMETER ClientSecret
The Application Secret generated when registering a new app for OAuth2.
.PARAMETER RedirectUrl
An optional OAuth2 Redirect URL (default: <host>/oauth2/callback)
.PARAMETER AuthoriseUrl
The OAuth2 Authorisation URL to authenticate a User. This is optional if you're using an InnerScheme like Basic/Form.
.PARAMETER TokenUrl
The OAuth2 Token URL to acquire an access token.
.PARAMETER UserUrl
An optional User profile URL to retrieve a user's details - for OAuth2
.PARAMETER OAuth2
If supplied, will use the inbuilt OAuth2 Authentication scheme.
.PARAMETER Scope
An optional array of Scopes for Bearer/OAuth2 Authentication. (These are case-sensitive)
.PARAMETER InnerScheme
An optional authentication Scheme (from New-PodeAuthScheme) that will be called prior to this Scheme.
.EXAMPLE
$basic_auth = New-PodeAuthScheme -Basic
.EXAMPLE
$form_auth = New-PodeAuthScheme -Form -UsernameField 'Email'
.EXAMPLE
$custom_auth = New-PodeAuthScheme -Custom -ScriptBlock { /* logic */ }
#>
function New-PodeAuthScheme
{
[CmdletBinding(DefaultParameterSetName='Basic')]
[OutputType([hashtable])]
param (
[Parameter(ParameterSetName='Basic')]
[switch]
$Basic,
[Parameter(ParameterSetName='Basic')]
[string]
$Encoding = 'ISO-8859-1',
[Parameter(ParameterSetName='Basic')]
[string]
$HeaderTag = 'Basic',
[Parameter(ParameterSetName='Form')]
[switch]
$Form,
[Parameter(ParameterSetName='Form')]
[string]
$UsernameField = 'username',
[Parameter(ParameterSetName='Form')]
[string]
$PasswordField = 'password',
[Parameter(ParameterSetName='Custom')]
[switch]
$Custom,
[Parameter(Mandatory=$true, ParameterSetName='Custom')]
[ValidateScript({
if (Test-PodeIsEmpty $_) {
throw "A non-empty ScriptBlock is required for the Custom authentication scheme"
}
return $true
})]
[scriptblock]
$ScriptBlock,
[Parameter(ParameterSetName='Custom')]
[hashtable]
$ArgumentList,
[Parameter(ParameterSetName='Custom')]
[string]
$Name,
[Parameter()]
[string]
$Realm,
[Parameter(ParameterSetName='Custom')]
[ValidateSet('ApiKey', 'Http', 'OAuth2', 'OpenIdConnect')]
[string]
$Type = 'Http',
[Parameter(ParameterSetName='Custom')]
[scriptblock]
$PostValidator,
[Parameter(ParameterSetName='Digest')]
[switch]
$Digest,
[Parameter(ParameterSetName='Bearer')]
[switch]
$Bearer,
[Parameter(ParameterSetName='ClientCertificate')]
[switch]
$ClientCertificate,
[Parameter(ParameterSetName='OAuth2', Mandatory=$true)]
[string]
$ClientId,
[Parameter(ParameterSetName='OAuth2', Mandatory=$true)]
[string]
$ClientSecret,
[Parameter(ParameterSetName='OAuth2')]
[string]
$RedirectUrl,
[Parameter(ParameterSetName='OAuth2')]
[string]
$AuthoriseUrl,
[Parameter(ParameterSetName='OAuth2', Mandatory=$true)]
[string]
$TokenUrl,
[Parameter(ParameterSetName='OAuth2')]
[string]
$UserUrl,
[Parameter(ParameterSetName='OAuth2')]
[switch]
$OAuth2,
[Parameter(ParameterSetName='Bearer')]
[Parameter(ParameterSetName='OAuth2')]
[string[]]
$Scope,
[Parameter(ValueFromPipeline=$true)]
[hashtable]
$InnerScheme
)
# default realm
$_realm = 'User'
# configure the auth scheme
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'basic' {
return @{
Name = (Protect-PodeValue -Value $HeaderTag -Default 'Basic')
Realm = (Protect-PodeValue -Value $Realm -Default $_realm)
ScriptBlock = @{
Script = (Get-PodeAuthBasicType)
UsingVariables = $null
}
PostValidator = $null
InnerScheme = $InnerScheme
Scheme = 'http'
Arguments = @{
HeaderTag = (Protect-PodeValue -Value $HeaderTag -Default 'Basic')
Encoding = (Protect-PodeValue -Value $Encoding -Default 'ISO-8859-1')
}
}
}
'clientcertificate' {
return @{
Name = 'Mutual'
Realm = (Protect-PodeValue -Value $Realm -Default $_realm)
ScriptBlock = @{
Script = (Get-PodeAuthClientCertificateType)
UsingVariables = $null
}
PostValidator = $null
InnerScheme = $InnerScheme
Scheme = 'http'
Arguments = @{}
}
}
'digest' {
return @{
Name = 'Digest'
Realm = (Protect-PodeValue -Value $Realm -Default $_realm)
ScriptBlock = @{
Script = (Get-PodeAuthDigestType)
UsingVariables = $null
}
PostValidator = @{
Script = (Get-PodeAuthDigestPostValidator)
UsingVariables = $null
}
InnerScheme = $InnerScheme
Scheme = 'http'
Arguments = @{}
}
}
'bearer' {
return @{
Name = 'Bearer'
Realm = (Protect-PodeValue -Value $Realm -Default $_realm)
ScriptBlock = @{
Script = (Get-PodeAuthBearerType)
UsingVariables = $null
}
PostValidator = @{
Script = (Get-PodeAuthBearerPostValidator)
UsingVariables = $null
}
Scheme = 'http'
InnerScheme = $InnerScheme
Arguments = @{
Scopes = $Scope
}
}
}
'form' {
return @{
Name = 'Form'
Realm = (Protect-PodeValue -Value $Realm -Default $_realm)
ScriptBlock = @{
Script = (Get-PodeAuthFormType)
UsingVariables = $null
}
PostValidator = $null
InnerScheme = $InnerScheme
Scheme = 'http'
Arguments = @{
Fields = @{
Username = (Protect-PodeValue -Value $UsernameField -Default 'username')
Password = (Protect-PodeValue -Value $PasswordField -Default 'password')
}
}
}
}
'oauth2' {
if (($null -ne $InnerScheme) -and ($InnerScheme.Name -inotin @('basic', 'form'))) {
throw "OAuth2 InnerScheme can only be one of either Basic or Form authentication, but got: $($InnerScheme.Name)"
}
if (($null -eq $InnerScheme) -and [string]::IsNullOrWhiteSpace($AuthoriseUrl)) {
throw "OAuth2 requires an Authorise URL to be supplied"
}
return @{
Name = 'OAuth2'
Realm = (Protect-PodeValue -Value $Realm -Default $_realm)
ScriptBlock = @{
Script = (Get-PodeAuthOAuth2Type)
UsingVariables = $null
}
PostValidator = $null
Scheme = 'oauth2'
InnerScheme = $InnerScheme
Arguments = @{
Scopes = $Scope
Client = @{
ID = $ClientId
Secret = $ClientSecret
}
Urls = @{
Redirect = $RedirectUrl
Authorise = $AuthoriseUrl
Token = $TokenUrl
User = $UserUrl
}
}
}
}
'custom' {
$ScriptBlock, $usingScriptVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
if (!(Test-PodeIsEmpty $PostValidator)) {
$PostValidator, $usingPostVars = Invoke-PodeUsingScriptConversion -ScriptBlock $PostValidator -PSSession $PSCmdlet.SessionState
}
return @{
Name = $Name
Realm = (Protect-PodeValue -Value $Realm -Default $_realm)
InnerScheme = $InnerScheme
Scheme = $Type.ToLowerInvariant()
ScriptBlock = @{
Script = $ScriptBlock
UsingVariables = $usingScriptVars
}
PostValidator = @{
Script = $PostValidator
UsingVariables = $usingPostVars
}
Arguments = $ArgumentList
}
}
}
}
<#
.SYNOPSIS
Create an OAuth2 auth scheme for Azure AD.
.DESCRIPTION
A wrapper for New-PodeAuthScheme and OAuth2, which builds an OAuth2 scheme for Azure AD.
.PARAMETER Tenant
The Directory/Tenant ID from registering a new app (default: common).
.PARAMETER ClientId
The Client ID from registering a new app.
.PARAMETER ClientSecret
The Client Secret from registering a new app.
.PARAMETER RedirectUrl
An optional OAuth2 Redirect URL (default: <host>/oauth2/callback)
.PARAMETER InnerScheme
An optional authentication Scheme (from New-PodeAuthScheme) that will be called prior to this Scheme.
.EXAMPLE
New-PodeAuthAzureADScheme -Tenant 123-456-678 -ClientId abcdef -ClientSecret 1234.abc
#>
function New-PodeAuthAzureADScheme
{
[CmdletBinding()]
param(
[Parameter()]
[ValidateNotNullOrEmpty()]
[string]
$Tenant = 'common',
[Parameter(Mandatory=$true)]
[string]
$ClientId,
[Parameter(Mandatory=$true)]
[string]
$ClientSecret,
[Parameter()]
[string]
$RedirectUrl,
[Parameter(ValueFromPipeline=$true)]
[hashtable]
$InnerScheme
)
return (New-PodeAuthScheme `
-OAuth2 `
-ClientId $ClientId `
-ClientSecret $ClientSecret `
-AuthoriseUrl "https://login.microsoftonline.com/$($Tenant)/oauth2/v2.0/authorize" `
-TokenUrl "https://login.microsoftonline.com/$($Tenant)/oauth2/v2.0/token" `
-UserUrl "https://graph.microsoft.com/oidc/userinfo" `
-RedirectUrl $RedirectUrl `
-InnerScheme $InnerScheme)
}
<#
.SYNOPSIS
Adds a custom Authentication method for verifying users.
.DESCRIPTION
Adds a custom Authentication method for verifying users.
.PARAMETER Name
A unique Name for the Authentication method.
.PARAMETER Scheme
The Scheme to use for retrieving credentials (From New-PodeAuthScheme).
.PARAMETER ScriptBlock
The ScriptBlock defining logic that retrieves and verifys a user.
.PARAMETER ArgumentList
An array of arguments to supply to the Custom Authentication's ScriptBlock.
.PARAMETER FailureUrl
The URL to redirect to when authentication fails.
.PARAMETER FailureMessage
An override Message to throw when authentication fails.
.PARAMETER SuccessUrl
The URL to redirect to when authentication succeeds when logging in.
.PARAMETER Sessionless
If supplied, authenticated users will not be stored in sessions, and sessions will not be used.
.EXAMPLE
New-PodeAuthScheme -Form | Add-PodeAuth -Name 'Main' -ScriptBlock { /* logic */ }
#>
function Add-PodeAuth
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$Scheme,
[Parameter(Mandatory=$true)]
[ValidateScript({
if (Test-PodeIsEmpty $_) {
throw "A non-empty ScriptBlock is required for the authentication method"
}
return $true
})]
[scriptblock]
$ScriptBlock,
[Parameter()]
[object[]]
$ArgumentList,
[Parameter()]
[string]
$FailureUrl,
[Parameter()]
[string]
$FailureMessage,
[Parameter()]
[string]
$SuccessUrl,
[switch]
$Sessionless
)
# ensure the name doesn't already exist
if (Test-PodeAuth -Name $Name) {
throw "Authentication method already defined: $($Name)"
}
# ensure the Scheme contains a scriptblock
if (Test-PodeIsEmpty $Scheme.ScriptBlock) {
throw "The supplied Scheme for the '$($Name)' authentication validator requires a valid ScriptBlock"
}
# if we're using sessions, ensure sessions have been setup
if (!$Sessionless -and !(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use session persistent authentication'
}
# check if the scriptblock has any using vars
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
# add auth method to server
$PodeContext.Server.Authentications[$Name] = @{
Scheme = $Scheme
ScriptBlock = $ScriptBlock
UsingVariables = $usingVars
Arguments = $ArgumentList
Sessionless = $Sessionless
Failure = @{
Url = $FailureUrl
Message = $FailureMessage
}
Success = @{
Url = $SuccessUrl
}
}
# if the scheme is oauth2, and there's no redirect, set up a default one
if (($Scheme.Name -ieq 'oauth2') -and ($null -eq $Scheme.InnerScheme) -and [string]::IsNullOrWhiteSpace($Scheme.Arguments.Urls.Redirect)) {
$path = '/oauth2/callback'
$Scheme.Arguments.Urls.Redirect = $path
Add-PodeRoute -Method Get -Path $path -Authentication $Name
}
}
<#
.SYNOPSIS
Gets an Authentication method.
.DESCRIPTION
Gets an Authentication method.
.PARAMETER Name
The Name of an Authentication method.
.EXAMPLE
Get-PodeAuth -Name 'Main'
#>
function Get-PodeAuth
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]
$Name
)
# ensure the name exists
if (!(Test-PodeAuth -Name $Name)) {
throw "Authentication method not defined: $($Name)"
}
# get auth method
return $PodeContext.Server.Authentications[$Name]
}
<#
.SYNOPSIS
Adds the inbuilt Windows AD Authentication method for verifying users.
.DESCRIPTION
Adds the inbuilt Windows AD Authentication method for verifying users.
.PARAMETER Name
A unique Name for the Authentication method.
.PARAMETER Scheme
The Scheme to use for retrieving credentials (From New-PodeAuthScheme).
.PARAMETER Fqdn
A custom FQDN for the DNS of the AD you wish to authenticate against. (Alias: Server)
.PARAMETER Domain
(Unix Only) A custom domain name that is prepended onto usernames that are missing it (<Domain>\<Username>).
.PARAMETER Groups
An array of Group names to only allow access.
.PARAMETER Users
An array of Usernames to only allow access.
.PARAMETER FailureUrl
The URL to redirect to when authentication fails.
.PARAMETER FailureMessage
An override Message to throw when authentication fails.
.PARAMETER SuccessUrl
The URL to redirect to when authentication succeeds when logging in.
.PARAMETER ScriptBlock
Optional ScriptBlock that is passed the found user object for further validation.
.PARAMETER Sessionless
If supplied, authenticated users will not be stored in sessions, and sessions will not be used.
.PARAMETER NoGroups
If supplied, groups will not be retrieved for the user in AD.
.PARAMETER OpenLDAP
If supplied, and on Windows, OpenLDAP will be used instead.
.EXAMPLE
New-PodeAuthScheme -Form | Add-PodeAuthWindowsAd -Name 'WinAuth'
.EXAMPLE
New-PodeAuthScheme -Basic | Add-PodeAuthWindowsAd -Name 'WinAuth' -Groups @('Developers')
.EXAMPLE
New-PodeAuthScheme -Form | Add-PodeAuthWindowsAd -Name 'WinAuth' -NoGroups
.EXAMPLE
New-PodeAuthScheme -Form | Add-PodeAuthWindowsAd -Name 'UnixAuth' -Server 'testdomain.company.com' -Domain 'testdomain'
#>
function Add-PodeAuthWindowsAd
{
[CmdletBinding(DefaultParameterSetName='Groups')]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$Scheme,
[Parameter()]
[Alias('Server')]
[string]
$Fqdn,
[Parameter()]
[string]
$Domain,
[Parameter(ParameterSetName='Groups')]
[string[]]
$Groups,
[Parameter()]
[string[]]
$Users,
[Parameter()]
[string]
$FailureUrl,
[Parameter()]
[string]
$FailureMessage,
[Parameter()]
[string]
$SuccessUrl,
[Parameter()]
[scriptblock]
$ScriptBlock,
[switch]
$Sessionless,
[Parameter(ParameterSetName='NoGroups')]
[switch]
$NoGroups,
[switch]
$OpenLDAP
)
# ensure the name doesn't already exist
if (Test-PodeAuth -Name $Name) {
throw "Windows AD Authentication method already defined: $($Name)"
}
# ensure the Scheme contains a scriptblock
if (Test-PodeIsEmpty $Scheme.ScriptBlock) {
throw "The supplied Scheme for the '$($Name)' Windows AD authentication validator requires a valid ScriptBlock"
}
# if we're using sessions, ensure sessions have been setup
if (!$Sessionless -and !(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use session persistent authentication'
}
# set server name if not passed
if ([string]::IsNullOrWhiteSpace($Fqdn)) {
$Fqdn = Get-PodeAuthDomainName
if ([string]::IsNullOrWhiteSpace($Fqdn)) {
throw 'No domain server name has been supplied for Windows AD authentication'
}
}
# set the domain if not passed
if ([string]::IsNullOrWhiteSpace($Domain)) {
$Domain = ($Fqdn -split '\.')[0]
}
# if we have a scriptblock, deal with using vars
if ($null -ne $ScriptBlock) {
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
}
# add Windows AD auth method to server
$PodeContext.Server.Authentications[$Name] = @{
Scheme = $Scheme
ScriptBlock = (Get-PodeAuthWindowsADMethod)
Arguments = @{
Server = $Fqdn
Domain = $Domain
Users = $Users
Groups = $Groups
NoGroups = $NoGroups
OpenLDAP = $OpenLDAP
ScriptBlock = @{
Script = $ScriptBlock
UsingVariables = $usingVars
}
}
Sessionless = $Sessionless
Failure = @{
Url = $FailureUrl
Message = $FailureMessage
}
Success = @{
Url = $SuccessUrl
}
}
}
<#
.SYNOPSIS
Remove a specific Authentication method.
.DESCRIPTION
Remove a specific Authentication method.
.PARAMETER Name
The Name of the Authentication method.
.EXAMPLE
Remove-PodeAuth -Name 'Login'
#>
function Remove-PodeAuth
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Name
)
$PodeContext.Server.Authentications.Remove($Name) | Out-Null
}
<#
.SYNOPSIS
Clear all defined Authentication methods.
.DESCRIPTION
Clear all defined Authentication methods.
.EXAMPLE
Clear-PodeAuth
#>
function Clear-PodeAuth
{
[CmdletBinding()]
param()
$PodeContext.Server.Authentications.Clear()
}
<#
.SYNOPSIS
Adds an authentication method as global middleware.
.DESCRIPTION
Adds an authentication method as global middleware.
.PARAMETER Name
The Name of the Middleware.
.PARAMETER Authentication
The Name of the Authentication method to use.
.PARAMETER Route
A Route path for which Routes this Middleware should only be invoked against.
.EXAMPLE
Add-PodeAuthMiddleware -Name 'GlobalAuth' -Authentication AuthName
.EXAMPLE
Add-PodeAuthMiddleware -Name 'GlobalAuth' -Authentication AuthName -Route '/api/*'
#>
function Add-PodeAuthMiddleware
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true)]
[Alias('Auth')]
[string]
$Authentication,
[Parameter()]
[string]
$Route
)
if (!(Test-PodeAuth -Name $Authentication)) {
throw "Authentication method does not exist: $($Authentication)"
}
Get-PodeAuthMiddlewareScript |
New-PodeMiddleware -ArgumentList @{ Name = $Authentication } |
Add-PodeMiddleware -Name $Name -Route $Route
Set-PodeOAGlobalAuth -Name $Authentication -Route $Route
}
<#
.SYNOPSIS
Adds the inbuilt IIS Authentication method for verifying users passed to Pode from IIS.
.DESCRIPTION
Adds the inbuilt IIS Authentication method for verifying users passed to Pode from IIS.
.PARAMETER Name
A unique Name for the Authentication method.
.PARAMETER Groups
An array of Group names to only allow access.
.PARAMETER Users
An array of Usernames to only allow access.
.PARAMETER FailureUrl
The URL to redirect to when authentication fails.
.PARAMETER FailureMessage
An override Message to throw when authentication fails.
.PARAMETER SuccessUrl
The URL to redirect to when authentication succeeds when logging in.
.PARAMETER ScriptBlock
Optional ScriptBlock that is passed the found user object for further validation.
.PARAMETER Sessionless
If supplied, authenticated users will not be stored in sessions, and sessions will not be used.
.PARAMETER NoGroups
If supplied, groups will not be retrieved for the user in AD.
.PARAMETER NoLocalCheck
If supplied, Pode will not at attempt to retrieve local User/Group information for the authenticated user.
.EXAMPLE
Add-PodeAuthIIS -Name 'IISAuth'
.EXAMPLE
Add-PodeAuthIIS -Name 'IISAuth' -Groups @('Developers')
.EXAMPLE
Add-PodeAuthIIS -Name 'IISAuth' -NoGroups
#>
function Add-PodeAuthIIS
{
[CmdletBinding(DefaultParameterSetName='Groups')]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(ParameterSetName='Groups')]
[string[]]
$Groups,
[Parameter()]
[string[]]
$Users,
[Parameter()]
[string]
$FailureUrl,
[Parameter()]
[string]
$FailureMessage,
[Parameter()]
[string]
$SuccessUrl,
[Parameter()]
[scriptblock]
$ScriptBlock,
[switch]
$Sessionless,
[Parameter(ParameterSetName='NoGroups')]
[switch]
$NoGroups,
[switch]
$NoLocalCheck
)
# ensure we're on Windows!
if (!(Test-PodeIsWindows)) {
throw "IIS Authentication support is for Windows only"
}
# ensure the name doesn't already exist
if (Test-PodeAuth -Name $Name) {
throw "IIS Authentication method already defined: $($Name)"
}
# if we have a scriptblock, deal with using vars
if ($null -ne $ScriptBlock) {
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
}
# create the auth scheme for getting the token header
$scheme = New-PodeAuthScheme -Custom -ScriptBlock {
param($options)
$header = 'MS-ASPNETCORE-WINAUTHTOKEN'
# fail if no header
if (!(Test-PodeHeader -Name $header)) {
return @{
Message = "No $($header) header found"
Code = 401
}
}
# return the header for validation
$token = Get-PodeHeader -Name $header
return @($token)
}
# add a custom auth method to validate the user
$method = Get-PodeAuthWindowsADIISMethod
$scheme | Add-PodeAuth `
-Name $Name `
-ScriptBlock $method `
-FailureUrl $FailureUrl `
-FailureMessage $FailureMessage `
-SuccessUrl $SuccessUrl `
-Sessionless:$Sessionless `
-ArgumentList @{
Users = $Users
Groups = $Groups
NoGroups = $NoGroups
NoLocalCheck = $NoLocalCheck
ScriptBlock = @{
Script = $ScriptBlock
UsingVariables = $usingVars
}
}
}
<#
.SYNOPSIS
Adds the inbuilt User File Authentication method for verifying users.
.DESCRIPTION
Adds the inbuilt User File Authentication method for verifying users.
.PARAMETER Name
A unique Name for the Authentication method.
.PARAMETER Scheme
The Scheme to use for retrieving credentials (From New-PodeAuthScheme).
.PARAMETER FilePath
A path to a users JSON file (Default: ./users.json)
.PARAMETER Groups
An array of Group names to only allow access.
.PARAMETER Users
An array of Usernames to only allow access.
.PARAMETER HmacSecret
An optional secret if the passwords are HMAC SHA256 hashed.
.PARAMETER FailureUrl
The URL to redirect to when authentication fails.
.PARAMETER FailureMessage
An override Message to throw when authentication fails.
.PARAMETER SuccessUrl
The URL to redirect to when authentication succeeds when logging in.
.PARAMETER ScriptBlock
Optional ScriptBlock that is passed the found user object for further validation.
.PARAMETER Sessionless
If supplied, authenticated users will not be stored in sessions, and sessions will not be used.
.EXAMPLE
New-PodeAuthScheme -Form | Add-PodeAuthUserFile -Name 'Login'
.EXAMPLE
New-PodeAuthScheme -Form | Add-PodeAuthUserFile -Name 'Login' -FilePath './custom/path/users.json'
#>
function Add-PodeAuthUserFile
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$Scheme,
[Parameter()]
[string]
$FilePath,
[Parameter()]
[string[]]
$Groups,
[Parameter()]
[string[]]
$Users,
[Parameter(ParameterSetName='Hmac')]
[string]
$HmacSecret,
[Parameter()]
[string]
$FailureUrl,
[Parameter()]
[string]
$FailureMessage,
[Parameter()]
[string]
$SuccessUrl,
[Parameter()]
[scriptblock]
$ScriptBlock,
[switch]
$Sessionless
)
# ensure the name doesn't already exist
if (Test-PodeAuth -Name $Name) {
throw "User File Authentication method already defined: $($Name)"
}
# ensure the Scheme contains a scriptblock
if (Test-PodeIsEmpty $Scheme.ScriptBlock) {
throw "The supplied Scheme for the '$($Name)' User File authentication validator requires a valid ScriptBlock"
}
# if we're using sessions, ensure sessions have been setup
if (!$Sessionless -and !(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use session persistent authentication'
}
# set the file path if not passed
if ([string]::IsNullOrWhiteSpace($FilePath)) {
$FilePath = Join-PodeServerRoot -Folder '.' -FilePath 'users.json'
}
else {
$FilePath = Get-PodeRelativePath -Path $FilePath -JoinRoot -Resolve
}
# ensure the user file exists
if (!(Test-PodePath -Path $FilePath -NoStatus -FailOnDirectory)) {
throw "The user file does not exist: $($FilePath)"
}
# if we have a scriptblock, deal with using vars
if ($null -ne $ScriptBlock) {
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
}
# add Windows AD auth method to server
$PodeContext.Server.Authentications[$Name] = @{
Scheme = $Scheme
ScriptBlock = (Get-PodeAuthUserFileMethod)
Arguments = @{
FilePath = $FilePath
Users = $Users
Groups = $Groups
HmacSecret = $HmacSecret
ScriptBlock = @{
Script = $ScriptBlock
UsingVariables = $usingVars
}
}
Sessionless = $Sessionless
Failure = @{
Url = $FailureUrl
Message = $FailureMessage
}
Success = @{
Url = $SuccessUrl
}
}
}
<#
.SYNOPSIS
Adds the inbuilt Windows Local User Authentication method for verifying users.
.DESCRIPTION
Adds the inbuilt Windows Local User Authentication method for verifying users.
.PARAMETER Name
A unique Name for the Authentication method.
.PARAMETER Scheme
The Scheme to use for retrieving credentials (From New-PodeAuthScheme).
.PARAMETER Groups
An array of Group names to only allow access.
.PARAMETER Users
An array of Usernames to only allow access.
.PARAMETER FailureUrl
The URL to redirect to when authentication fails.
.PARAMETER FailureMessage
An override Message to throw when authentication fails.
.PARAMETER SuccessUrl
The URL to redirect to when authentication succeeds when logging in.
.PARAMETER ScriptBlock
Optional ScriptBlock that is passed the found user object for further validation.
.PARAMETER Sessionless
If supplied, authenticated users will not be stored in sessions, and sessions will not be used.
.PARAMETER NoGroups
If supplied, groups will not be retrieved for the user.
.EXAMPLE
New-PodeAuthScheme -Form | Add-PodeAuthWindowsLocal -Name 'WinAuth'
.EXAMPLE
New-PodeAuthScheme -Basic | Add-PodeAuthWindowsLocal -Name 'WinAuth' -Groups @('Developers')
.EXAMPLE
New-PodeAuthScheme -Form | Add-PodeAuthWindowsLocal -Name 'WinAuth' -NoGroups
#>
function Add-PodeAuthWindowsLocal
{
[CmdletBinding(DefaultParameterSetName='Groups')]
param(
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$Scheme,
[Parameter(ParameterSetName='Groups')]
[string[]]
$Groups,
[Parameter()]
[string[]]
$Users,
[Parameter()]
[string]
$FailureUrl,
[Parameter()]
[string]
$FailureMessage,
[Parameter()]
[string]
$SuccessUrl,
[Parameter()]
[scriptblock]
$ScriptBlock,
[switch]
$Sessionless,
[Parameter(ParameterSetName='NoGroups')]
[switch]
$NoGroups
)
# ensure we're on Windows!
if (!(Test-PodeIsWindows)) {
throw "Windows Local Authentication support is for Windows only"
}
# ensure the name doesn't already exist
if (Test-PodeAuth -Name $Name) {
throw "Windows Local Authentication method already defined: $($Name)"
}
# ensure the Scheme contains a scriptblock
if (Test-PodeIsEmpty $Scheme.ScriptBlock) {
throw "The supplied Scheme for the '$($Name)' Windows Local authentication validator requires a valid ScriptBlock"
}
# if we're using sessions, ensure sessions have been setup
if (!$Sessionless -and !(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use session persistent authentication'
}
# if we have a scriptblock, deal with using vars
if ($null -ne $ScriptBlock) {
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
}
# add Windows Local auth method to server
$PodeContext.Server.Authentications[$Name] = @{
Scheme = $Scheme
ScriptBlock = (Get-PodeAuthWindowsLocalMethod)
Arguments = @{
Users = $Users
Groups = $Groups
NoGroups = $NoGroups
ScriptBlock = @{
Script = $ScriptBlock
UsingVariables = $usingVars
}
}
Sessionless = $Sessionless
Failure = @{
Url = $FailureUrl
Message = $FailureMessage
}
Success = @{
Url = $SuccessUrl
}
}
}
<#
.SYNOPSIS
Exports modules that can be auto-imported by Pode, and into its runspaces.
.DESCRIPTION
Exports modules that can be auto-imported by Pode, and into its runspaces.
.PARAMETER Name
The Name(s) of modules to export.
.EXAMPLE
Export-PodeModule -Name Mod1, Mod2
#>
function Export-PodeModule
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string[]]
$Name
)
$PodeContext.Server.AutoImport.Modules.ExportList += @($Name)
}
<#
.SYNOPSIS
Exports snapins that can be auto-imported by Pode, and into its runspaces.
.DESCRIPTION
Exports snapins that can be auto-imported by Pode, and into its runspaces.
.PARAMETER Name
The Name(s) of snapins to export.
.EXAMPLE
Export-PodeSnapin -Name Mod1, Mod2
#>
function Export-PodeSnapin
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string[]]
$Name
)
# if non-windows or core, fail
if ((Test-PodeIsPSCore) -or (Test-PodeIsUnix)) {
throw 'Snapins are only supported on Windows PowerShell'
}
$PodeContext.Server.AutoImport.Snapins.ExportList += @($Name)
}
<#
.SYNOPSIS
Exports functions that can be auto-imported by Pode, and into its runspaces.
.DESCRIPTION
Exports functions that can be auto-imported by Pode, and into its runspaces.
.PARAMETER Name
The Name(s) of functions to export.
.EXAMPLE
Export-PodeFunction -Name Mod1, Mod2
#>
function Export-PodeFunction
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string[]]
$Name
)
$PodeContext.Server.AutoImport.Functions.ExportList += @($Name)
}
<#
.SYNOPSIS
Starts a Pode Server with the supplied ScriptBlock.
.DESCRIPTION
Starts a Pode Server with the supplied ScriptBlock.
.PARAMETER ScriptBlock
The main logic for the Server.
.PARAMETER FilePath
A literal, or relative, path to a file containing a ScriptBlock for the Server's logic.
The directory of this file will be used as the Server's root path - unless a specific -RootPath is supplied.
.PARAMETER Interval
For 'Service' type Servers, will invoke the ScriptBlock every X seconds.
.PARAMETER Name
An optional name for the Server (intended for future ideas).
.PARAMETER Threads
The numbers of threads to use for Web and TCP servers.
.PARAMETER RootPath
An override for the Server's root path.
.PARAMETER Request
Intended for Serverless environments, this is Requests details that Pode can parse and use.
.PARAMETER ServerlessType
Optional, this is the serverless type, to define how Pode should run and deal with incoming Requests.
.PARAMETER StatusPageExceptions
An optional value of Show/Hide to control where Stacktraces are shown in the Status Pages.
If supplied this value will override the ShowExceptions setting in the server.psd1 file.
.PARAMETER DisableTermination
Disables the ability to terminate the Server.
.PARAMETER Quiet
Disables any output from the Server.
.PARAMETER Browse
Open the web Server's default endpoint in your default browser.
.PARAMETER CurrentPath
Sets the Server's root path to be the current working path - for -FilePath only.
.EXAMPLE
Start-PodeServer { /* logic */ }
.EXAMPLE
Start-PodeServer -Interval 10 { /* logic */ }
.EXAMPLE
Start-PodeServer -Request $LambdaInput -ServerlessType AwsLambda { /* logic */ }
#>
function Start-PodeServer
{
[CmdletBinding(DefaultParameterSetName='Script')]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true, Position=0, ParameterSetName='Script')]
[scriptblock]
$ScriptBlock,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$FilePath,
[Parameter()]
[int]
$Interval = 0,
[Parameter()]
[string]
$Name,
[Parameter()]
[int]
$Threads = 1,
[Parameter()]
[string]
$RootPath,
[Parameter()]
$Request,
[Parameter()]
[ValidateSet('', 'AzureFunctions', 'AwsLambda')]
[string]
$ServerlessType = [string]::Empty,
[Parameter()]
[ValidateSet('', 'Hide', 'Show')]
[string]
$StatusPageExceptions = [string]::Empty,
[Parameter()]
[string]
$ListenerType = [string]::Empty,
[switch]
$DisableTermination,
[switch]
$Quiet,
[switch]
$Browse,
[Parameter(ParameterSetName='File')]
[switch]
$CurrentPath
)
# ensure the session is clean
$PodeContext = $null
$ShowDoneMessage = $true
try {
# if we have a filepath, resolve it - and extract a root path from it
if ($PSCmdlet.ParameterSetName -ieq 'file') {
$FilePath = Get-PodeRelativePath -Path $FilePath -Resolve -TestPath
# if not already supplied, set root path
if ([string]::IsNullOrWhiteSpace($RootPath)) {
if ($CurrentPath) {
$RootPath = $PWD.Path
}
else {
$RootPath = Split-Path -Parent -Path $FilePath
}
}
}
# configure the server's root path
if (!(Test-PodeIsEmpty $RootPath)) {
$RootPath = Get-PodeRelativePath -Path $RootPath -RootPath $MyInvocation.PSScriptRoot -JoinRoot -Resolve -TestPath
}
# create main context object
$PodeContext = New-PodeContext `
-ScriptBlock $ScriptBlock `
-FilePath $FilePath `
-Threads $Threads `
-Interval $Interval `
-ServerRoot (Protect-PodeValue -Value $RootPath -Default $MyInvocation.PSScriptRoot) `
-ServerlessType $ServerlessType `
-ListenerType $ListenerType `
-StatusPageExceptions $StatusPageExceptions `
-DisableTermination:$DisableTermination `
-Quiet:$Quiet
# set it so ctrl-c can terminate, unless serverless/iis, or disabled
if (!$PodeContext.Server.DisableTermination) {
[Console]::TreatControlCAsInput = $true
}
# start the file monitor for interally restarting
Start-PodeFileMonitor
# start the server
Start-PodeInternalServer -Request $Request -Browse:$Browse
# at this point, if it's just a one-one off script, return
if (($PodeContext.Server.Types.Length -eq 0) -or $PodeContext.Server.IsServerless) {
return
}
# sit here waiting for termination/cancellation, or to restart the server
while (!(Test-PodeTerminationPressed -Key $key) -and !($PodeContext.Tokens.Cancellation.IsCancellationRequested)) {
Start-Sleep -Seconds 1
# get the next key presses
$key = Get-PodeConsoleKey
# check for internal restart
if (($PodeContext.Tokens.Restart.IsCancellationRequested) -or (Test-PodeRestartPressed -Key $key)) {
Restart-PodeInternalServer
}
# check for open browser
if (Test-PodeOpenBrowserPressed -Key $key) {
Start-Process (Get-PodeEndpointUrl)
}
}
Write-PodeHost 'Terminating...' -NoNewline -ForegroundColor Yellow
$PodeContext.Tokens.Cancellation.Cancel()
}
catch {
$ShowDoneMessage = $false
throw
}
finally {
# clean the runspaces and tokens
Close-PodeServerInternal -ShowDoneMessage:$ShowDoneMessage
# clean the session
$PodeContext = $null
}
}
<#
.SYNOPSIS
Closes the Pode server.
.DESCRIPTION
Closes the Pode server.
.EXAMPLE
Close-PodeServer
#>
function Close-PodeServer
{
[CmdletBinding()]
param()
$PodeContext.Tokens.Cancellation.Cancel()
}
<#
.SYNOPSIS
Helper wrapper function to start a Pode web server for a static website at the current directory.
.DESCRIPTION
Helper wrapper function to start a Pode web server for a static website at the current directory.
.PARAMETER Threads
The numbers of threads to use for requests.
.PARAMETER RootPath
An override for the Server's root path.
.PARAMETER Address
The IP/Hostname of the endpoint.
.PARAMETER Port
The Port number of the endpoint.
.PARAMETER Https
Start the server using HTTPS.
.PARAMETER Certificate
The path to a certificate that can be use to enable HTTPS.
.PARAMETER CertificatePassword
The password for the certificate referenced in CertificateFile.
.PARAMETER X509Certificate
The raw X509 certificate that can be use to enable HTTPS.
.PARAMETER Path
The URI path for the static Route.
.PARAMETER Defaults
An array of default pages to display, such as 'index.html'.
.PARAMETER DownloadOnly
When supplied, all static content on this Route will be attached as downloads - rather than rendered.
.PARAMETER Browse
Open the web server's default endpoint in your default browser.
.EXAMPLE
Start-PodeStaticServer
.EXAMPLE
Start-PodeStaticServer -Address '127.0.0.3' -Port 8000
.EXAMPLE
Start-PodeStaticServer -Path '/installers' -DownloadOnly
#>
function Start-PodeStaticServer
{
[CmdletBinding()]
param(
[Parameter()]
[int]
$Threads = 3,
[Parameter()]
[string]
$RootPath = $PWD,
[Parameter()]
[string]
$Address = 'localhost',
[Parameter()]
[int]
$Port = 0,
[Parameter(ParameterSetName='Https')]
[switch]
$Https,
[Parameter(ParameterSetName='Https')]
[string]
$Certificate = $null,
[Parameter(ParameterSetName='Https')]
[string]
$CertificatePassword = $null,
[Parameter(ParameterSetName='Https')]
[Parameter()]
[X509Certificate]
$X509Certificate = $null,
[Parameter()]
[string]
$Path = '/',
[Parameter()]
[string[]]
$Defaults,
[switch]
$DownloadOnly,
[switch]
$Browse
)
Start-PodeServer -RootPath $RootPath -Threads $Threads -Browse:$Browse -ScriptBlock {
# add either an http or https endpoint
if ($Https) {
if ($null -eq $X509Certificate) {
Add-PodeEndpoint -Address $Address -Port $Port -Protocol Https -Certificate $Certificate -CertificatePassword $CertificatePassword
}
else {
Add-PodeEndpoint -Address $Address -Port $Port -Protocol Https -X509Certificate $X509Certificate
}
}
else {
Add-PodeEndpoint -Address $Address -Port $Port -Protocol Http
}
# add the static route
Add-PodeStaticRoute -Path $Path -Source (Get-PodeServerPath) -Defaults $Defaults -DownloadOnly:$DownloadOnly
}
}
<#
.SYNOPSIS
The CLI for Pode, to initialise, build and start your Server.
.DESCRIPTION
The CLI for Pode, to initialise, build and start your Server.
.PARAMETER Action
The action to invoke on your Server.
.PARAMETER Dev
Supply when running "pode install", this will install any dev packages defined in your package.json.
.EXAMPLE
pode install -dev
.EXAMPLE
pode build
.EXAMPLE
pode start
#>
function Pode
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[ValidateSet('init', 'test', 'start', 'install', 'build')]
[Alias('a')]
[string]
$Action,
[switch]
[Alias('d')]
$Dev
)
# default config file name and content
$file = './package.json'
$name = Split-Path -Leaf -Path $pwd
$data = $null
# default config data that's used to populate on init
$map = @{
'name' = $name;
'version' = '1.0.0';
'description' = '';
'main' = './server.ps1';
'scripts' = @{
'start' = './server.ps1';
'install' = 'yarn install --force --ignore-scripts --modules-folder pode_modules';
"build" = 'psake';
'test' = 'invoke-pester ./tests/*.ps1'
};
'author' = '';
'license' = 'MIT';
}
# check and load config if already exists
if (Test-Path $file) {
$data = (Get-Content $file | ConvertFrom-Json)
}
# quick check to see if the data is required
if ($Action -ine 'init') {
if ($null -eq $data) {
Write-Host 'package.json file not found' -ForegroundColor Red
return
}
else {
$actionScript = $data.scripts.$Action
if ([string]::IsNullOrWhiteSpace($actionScript) -and $Action -ieq 'start') {
$actionScript = $data.main
}
if ([string]::IsNullOrWhiteSpace($actionScript) -and $Action -ine 'install') {
Write-Host "package.json does not contain a script for the $($Action) action" -ForegroundColor Yellow
return
}
}
}
else {
if ($null -ne $data) {
Write-Host 'package.json already exists' -ForegroundColor Yellow
return
}
}
switch ($Action.ToLowerInvariant())
{
'init' {
$v = Read-Host -Prompt "name ($($map.name))"
if (![string]::IsNullOrWhiteSpace($v)) { $map.name = $v }
$v = Read-Host -Prompt "version ($($map.version))"
if (![string]::IsNullOrWhiteSpace($v)) { $map.version = $v }
$map.description = Read-Host -Prompt "description"
$v = Read-Host -Prompt "entry point ($($map.main))"
if (![string]::IsNullOrWhiteSpace($v)) { $map.main = $v; $map.scripts.start = $v }
$map.author = Read-Host -Prompt "author"
$v = Read-Host -Prompt "license ($($map.license))"
if (![string]::IsNullOrWhiteSpace($v)) { $map.license = $v }
$map | ConvertTo-Json -Depth 10 | Out-File -FilePath $file -Encoding utf8 -Force
Write-Host 'Success, saved package.json' -ForegroundColor Green
}
'test' {
Invoke-PodePackageScript -ActionScript $actionScript
}
'start' {
Invoke-PodePackageScript -ActionScript $actionScript
}
'install' {
if ($Dev) {
Install-PodeLocalModules -Modules $data.devModules
}
Install-PodeLocalModules -Modules $data.modules
Invoke-PodePackageScript -ActionScript $actionScript
}
'build' {
Invoke-PodePackageScript -ActionScript $actionScript
}
}
}
<#
.SYNOPSIS
Opens a Web Server up as a Desktop Application.
.DESCRIPTION
Opens a Web Server up as a Desktop Application.
.PARAMETER Title
The title of the Application's window.
.PARAMETER Icon
A path to an icon image for the Application.
.PARAMETER WindowState
The state the Application's window starts, such as Minimized.
.PARAMETER WindowStyle
The border style of the Application's window.
.PARAMETER ResizeMode
Specifies if the Application's window is resizable.
.PARAMETER Height
The height of the window.
.PARAMETER Width
The width of the window.
.PARAMETER EndpointName
The specific endpoint name to use, if you are listening on multiple endpoints.
.PARAMETER HideFromTaskbar
Stops the Application from appearing on the taskbar.
.EXAMPLE
Show-PodeGui -Title 'MyApplication' -WindowState 'Maximized'
#>
function Show-PodeGui
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Title,
[Parameter()]
[string]
$Icon,
[Parameter()]
[ValidateSet('Normal', 'Maximized', 'Minimized')]
[string]
$WindowState = 'Normal',
[Parameter()]
[ValidateSet('None', 'SingleBorderWindow', 'ThreeDBorderWindow', 'ToolWindow')]
[string]
$WindowStyle = 'SingleBorderWindow',
[Parameter()]
[ValidateSet('CanResize', 'CanMinimize', 'NoResize')]
[string]
$ResizeMode = 'CanResize',
[Parameter()]
[int]
$Height = 0,
[Parameter()]
[int]
$Width = 0,
[Parameter()]
[string]
$EndpointName,
[switch]
$HideFromTaskbar
)
# error if serverless
Test-PodeIsServerless -FunctionName 'Show-PodeGui' -ThrowError
# only valid for Windows PowerShell
if ((Test-PodeIsPSCore) -and ($PSVersionTable.PSVersion.Major -eq 6)) {
throw 'Show-PodeGui is currently only available for Windows PowerShell, and PowerShell 7 on Windows'
}
# enable the gui and set general settings
$PodeContext.Server.Gui.Enabled = $true
$PodeContext.Server.Gui.Title = $Title
$PodeContext.Server.Gui.ShowInTaskbar = !$HideFromTaskbar
$PodeContext.Server.Gui.WindowState = $WindowState
$PodeContext.Server.Gui.WindowStyle = $WindowStyle
$PodeContext.Server.Gui.ResizeMode = $ResizeMode
# set the window's icon path
if (![string]::IsNullOrWhiteSpace($Icon)) {
$PodeContext.Server.Gui.Icon = (Resolve-Path $Icon).Path
if (!(Test-Path $PodeContext.Server.Gui.Icon)) {
throw "Path to icon for GUI does not exist: $($PodeContext.Server.Gui.Icon)"
}
}
# set the height of the window
$PodeContext.Server.Gui.Height = $Height
if ($PodeContext.Server.Gui.Height -le 0) {
$PodeContext.Server.Gui.Height = 'auto'
}
# set the width of the window
$PodeContext.Server.Gui.Width = $Width
if ($PodeContext.Server.Gui.Width -le 0) {
$PodeContext.Server.Gui.Width = 'auto'
}
# set the gui to use a specific listener
$PodeContext.Server.Gui.EndpointName = $EndpointName
if (![string]::IsNullOrWhiteSpace($EndpointName)) {
if (!$PodeContext.Server.Endpoints.ContainsKey($EndpointName)) {
throw "Endpoint with name '$($EndpointName)' does not exist"
}
$PodeContext.Server.Gui.Endpoint = $PodeContext.Server.Endpoints[$EndpointName]
}
}
<#
.SYNOPSIS
Bind an endpoint to listen for incoming Requests.
.DESCRIPTION
Bind an endpoint to listen for incoming Requests. The endpoints can be HTTP, HTTPS, TCP or SMTP, with the option to bind certificates.
.PARAMETER Address
The IP/Hostname of the endpoint (Default: localhost).
.PARAMETER Port
The Port number of the endpoint.
.PARAMETER Hostname
An optional hostname for the endpoint, specifying a hostname restricts access to just the hostname.
.PARAMETER Protocol
The protocol of the supplied endpoint.
.PARAMETER Certificate
The path to a certificate that can be use to enable HTTPS
.PARAMETER CertificatePassword
The password for the certificate file referenced in Certificate
.PARAMETER CertificateThumbprint
A certificate thumbprint to bind onto HTTPS endpoints (Windows).
.PARAMETER CertificateName
A certificate subject name to bind onto HTTPS endpoints (Windows).
.PARAMETER CertificateStoreName
The name of a certifcate store where a certificate can be found (Default: My) (Windows).
.PARAMETER CertificateStoreLocation
The location of a certifcate store where a certificate can be found (Default: CurrentUser) (Windows).
.PARAMETER X509Certificate
The raw X509 certificate that can be use to enable HTTPS
.PARAMETER Name
An optional name for the endpoint, that can be used with other functions (Default: GUID).
.PARAMETER RedirectTo
The Name of another Endpoint to automatically generate a redirect route for all traffic.
.PARAMETER Description
A quick description of the Endpoint - normally used in OpenAPI.
.PARAMETER Force
Ignore Adminstrator checks for non-localhost endpoints.
.PARAMETER SelfSigned
Create and bind a self-signed certifcate for HTTPS endpoints.
.PARAMETER AllowClientCertificate
Allow for client certificates to be sent on requests.
.PARAMETER PassThru
If supplied, the endpoint created will be returned.
.PARAMETER LookupHostname
If supplied, a supplied Hostname will have its IP Address looked up from host file or DNS.
.PARAMETER Default
If supplied, this endpoint will be the default one used for internally generating URLs.
.EXAMPLE
Add-PodeEndpoint -Address localhost -Port 8090 -Protocol Http
.EXAMPLE
Add-PodeEndpoint -Address localhost -Protocol Smtp
.EXAMPLE
Add-PodeEndpoint -Address dev.pode.com -Port 8443 -Protocol Https -SelfSigned
.EXAMPLE
Add-PodeEndpoint -Address 127.0.0.2 -Hostname dev.pode.com -Port 8443 -Protocol Https -SelfSigned
.EXAMPLE
Add-PodeEndpoint -Address live.pode.com -Protocol Https -CertificateThumbprint '2A9467F7D3940243D6C07DE61E7FCCE292'
#>
function Add-PodeEndpoint
{
[CmdletBinding(DefaultParameterSetName='Default')]
param (
[Parameter()]
[string]
$Address = 'localhost',
[Parameter()]
[int]
$Port = 0,
[Parameter()]
[string]
$Hostname,
[Parameter()]
[ValidateSet('Http', 'Https', 'Smtp', 'Tcp', 'Ws', 'Wss')]
[string]
$Protocol,
[Parameter(Mandatory=$true, ParameterSetName='CertFile')]
[string]
$Certificate = $null,
[Parameter(ParameterSetName='CertFile')]
[string]
$CertificatePassword = $null,
[Parameter(Mandatory=$true, ParameterSetName='CertThumb')]
[string]
$CertificateThumbprint,
[Parameter(Mandatory=$true, ParameterSetName='CertName')]
[string]
$CertificateName,
[Parameter(ParameterSetName='CertName')]
[Parameter(ParameterSetName='CertThumb')]
[System.Security.Cryptography.X509Certificates.StoreName]
$CertificateStoreName = 'My',
[Parameter(ParameterSetName='CertName')]
[Parameter(ParameterSetName='CertThumb')]
[System.Security.Cryptography.X509Certificates.StoreLocation]
$CertificateStoreLocation = 'CurrentUser',
[Parameter(Mandatory=$true, ParameterSetName='CertRaw')]
[Parameter()]
[X509Certificate]
$X509Certificate = $null,
[Parameter()]
[string]
$Name = $null,
[Parameter()]
[string]
$RedirectTo = $null,
[Parameter()]
[string]
$Description,
[switch]
$Force,
[Parameter(ParameterSetName='CertSelf')]
[switch]
$SelfSigned,
[switch]
$AllowClientCertificate,
[switch]
$PassThru,
[switch]
$LookupHostname,
[switch]
$Default
)
# error if serverless
Test-PodeIsServerless -FunctionName 'Add-PodeEndpoint' -ThrowError
# if RedirectTo is supplied, then a Name is mandatory
if (![string]::IsNullOrWhiteSpace($RedirectTo) -and [string]::IsNullOrWhiteSpace($Name)) {
throw "A Name is required for the endpoint if the RedirectTo parameter is supplied"
}
# are we running as IIS for HTTP/HTTPS? (if yes, force the port, address and protocol)
$isIIS = ($PodeContext.Server.IsIIS -and (@('Http', 'Https') -icontains $Protocol))
if ($isIIS) {
$Port = [int]$env:ASPNETCORE_PORT
$Address = '127.0.0.1'
$Hostname = [string]::Empty
$Protocol = 'Http'
}
# are we running as Heroku for HTTP/HTTPS? (if yes, force the port, address and protocol)
$isHeroku = ($PodeContext.Server.IsHeroku -and (@('Http', 'Https') -icontains $Protocol))
if ($isHeroku) {
$Port = [int]$env:PORT
$Address = '0.0.0.0'
$Hostname = [string]::Empty
$Protocol = 'Http'
}
# parse the endpoint for host/port info
if (![string]::IsNullOrWhiteSpace($Hostname) -and !(Test-PodeHostname -Hostname $Hostname)) {
throw "Invalid hostname supplied: $($Hostname)"
}
if ((Test-PodeHostname -Hostname $Address) -and ($Address -inotin @('localhost', 'all'))) {
$Hostname = $Address
$Address = 'localhost'
}
if (![string]::IsNullOrWhiteSpace($Hostname) -and $LookupHostname) {
$Address = (Get-PodeIPAddressesForHostname -Hostname $Hostname -Type All | Select-Object -First 1)
}
$_endpoint = Get-PodeEndpointInfo -Address "$($Address):$($Port)"
# if no name, set to guid, then check uniqueness
if ([string]::IsNullOrWhiteSpace($Name)) {
$Name = New-PodeGuid -Secure
}
if ($PodeContext.Server.Endpoints.ContainsKey($Name)) {
throw "An endpoint with the name '$($Name)' has already been defined"
}
# protocol must be https for client certs
if (($Protocol -ine 'https') -and $AllowClientCertificate) {
throw "Client certificates are only supported on HTTPS endpoints"
}
# new endpoint object
$obj = @{
Name = $Name
Description = $Description
Address = $null
RawAddress = $null
Port = $null
IsIPAddress = $true
HostName = $Hostname
FriendlyName = $Hostname
Url = $null
Ssl = (@('https', 'wss') -icontains $Protocol)
Protocol = $Protocol.ToLowerInvariant()
Default = $Default.IsPresent
Certificate = @{
Raw = $X509Certificate
SelfSigned = $SelfSigned
AllowClientCertificate = $AllowClientCertificate
}
}
# set the ip for the context (force to localhost for IIS)
$obj.Address = (Get-PodeIPAddress $_endpoint.Host)
$obj.IsIPAddress = [string]::IsNullOrWhiteSpace($obj.HostName)
if ($obj.IsIPAddress) {
$obj.FriendlyName = 'localhost'
if (!(Test-PodeIPAddressLocalOrAny -IP $obj.Address)) {
$obj.FriendlyName = "$($obj.Address)"
}
}
# set the port for the context, if 0 use a default port for protocol
$obj.Port = $_endpoint.Port
if (([int]$obj.Port) -eq 0) {
$obj.Port = Get-PodeDefaultPort -Protocol $Protocol
}
if ($obj.IsIPAddress) {
$obj.RawAddress = "$($obj.Address):$($obj.Port)"
}
else {
$obj.RawAddress = "$($obj.FriendlyName):$($obj.Port)"
}
# set the url of this endpoint
$obj.Url = "$($obj.Protocol)://$($obj.FriendlyName):$($obj.Port)/"
# if the address is non-local, then check admin privileges
if (!$Force -and !(Test-PodeIPAddressLocal -IP $obj.Address) -and !(Test-PodeIsAdminUser)) {
throw 'Must be running with administrator priviledges to listen on non-localhost addresses'
}
# has this endpoint been added before? (for http/https we can just not add it again)
$exists = ($PodeContext.Server.Endpoints.Values | Where-Object {
($_.FriendlyName -eq $obj.FriendlyName) -and ($_.Port -eq $obj.Port) -and ($_.Ssl -eq $obj.Ssl)
} | Measure-Object).Count
# if we're dealing with a certificate, attempt to import it
if (!$isIIS -and !$isHeroku -and ($PSCmdlet.ParameterSetName -ilike 'cert*')) {
# fail if protocol is not https
if (@('https', 'wss') -inotcontains $Protocol) {
throw "Certificate supplied for non-HTTPS/WSS endpoint"
}
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant())
{
'certfile' {
$obj.Certificate.Raw = Get-PodeCertificateByFile -Certificate $Certificate -Password $CertificatePassword
}
'certthumb' {
$obj.Certificate.Raw = Get-PodeCertificateByThumbprint -Thumbprint $CertificateThumbprint -StoreName $CertificateStoreName -StoreLocation $CertificateStoreLocation
}
'certname' {
$obj.Certificate.Raw = Get-PodeCertificateByName -Name $CertificateName -StoreName $CertificateStoreName -StoreLocation $CertificateStoreLocation
}
'certself' {
$obj.Certificate.Raw = New-PodeSelfSignedCertificate
}
}
# fail if the cert is expired
if ($obj.Certificate.Raw.NotAfter -lt [datetime]::Now) {
throw "The certificate '$($obj.Certificate.Raw.Subject)' has expired: $($obj.Certificate.Raw.NotAfter)"
}
}
if (!$exists) {
# has an endpoint already been defined for smtp/tcp?
if ((@('smtp', 'tcp') -icontains $Protocol) -and ($PodeContext.Server.Types -icontains $Protocol)) {
throw "An endpoint for $($Protocol.ToUpperInvariant()) has already been defined"
}
# set server type
$_type = (Resolve-PodeValue -Check ($Protocol -ieq 'https') -TrueValue 'http' -FalseValue $Protocol)
$_type = (Resolve-PodeValue -Check ($_type -ieq 'wss') -TrueValue 'ws' -FalseValue $_type)
if ($PodeContext.Server.Types -inotcontains $_type) {
$PodeContext.Server.Types += $_type
}
# add the new endpoint
$PodeContext.Server.Endpoints[$Name] = $obj
$PodeContext.Server.EndpointsMap["$($obj.Protocol)|$($obj.RawAddress)"] = $Name
}
# if RedirectTo is set, attempt to build a redirecting route
if (!$isIIS -and !$isHeroku -and ![string]::IsNullOrWhiteSpace($RedirectTo)) {
$redir_endpoint = $PodeContext.Server.Endpoints[$RedirectTo]
# ensure the name exists
if (Test-PodeIsEmpty $redir_endpoint) {
throw "An endpoint with the name '$($RedirectTo)' has not been defined for redirecting"
}
# build the redirect route
Add-PodeRoute -Method * -Path * -EndpointName $obj.Name -ArgumentList $redir_endpoint -ScriptBlock {
param($endpoint)
Move-PodeResponseUrl -EndpointName $endpoint.Name
}
}
# return the endpoint?
if ($PassThru) {
return $obj
}
}
<#
.SYNOPSIS
Get an Endpoint(s).
.DESCRIPTION
Get an Endpoint(s).
.PARAMETER Address
An Address to filter the endpoints.
.PARAMETER Port
A Port to filter the endpoints.
.PARAMETER Hostname
A Hostname to filter the endpoints.
.PARAMETER Protocol
A Protocol to filter the endpoints.
.PARAMETER Name
Any endpoints Names to filter endpoints.
.EXAMPLE
Get-PodeEndpoint -Address 127.0.0.1
.EXAMPLE
Get-PodeEndpoint -Protocol Http
.EXAMPLE
Get-PodeEndpoint -Name Admin, User
#>
function Get-PodeEndpoint
{
[CmdletBinding()]
param(
[Parameter()]
[string]
$Address,
[Parameter()]
[int]
$Port = 0,
[Parameter()]
[string]
$Hostname,
[Parameter()]
[ValidateSet('', 'Http', 'Https', 'Smtp', 'Tcp', 'Ws', 'Wss')]
[string]
$Protocol,
[Parameter()]
[string[]]
$Name
)
if ((Test-PodeHostname -Hostname $Address) -and ($Address -inotin @('localhost', 'all'))) {
$Hostname = $Address
$Address = 'localhost'
}
$endpoints = $PodeContext.Server.Endpoints.Values
# if we have an address, filter
if (![string]::IsNullOrWhiteSpace($Address)) {
if (($Address -eq '*') -or $PodeContext.Server.IsHeroku) {
$Address = '0.0.0.0'
}
if ($PodeContext.Server.IsIIS -or ($Address -ieq 'localhost')) {
$Address = '127.0.0.1'
}
$endpoints = @(foreach ($endpoint in $endpoints) {
if ($endpoint.Address.ToString() -ine $Address) {
continue
}
$endpoint
})
}
# if we have a hostname, filter
if (![string]::IsNullOrWhiteSpace($Hostname)) {
$endpoints = @(foreach ($endpoint in $endpoints) {
if ($endpoint.Hostname.ToString() -ine $Hostname) {
continue
}
$endpoint
})
}
# if we have a port, filter
if ($Port -gt 0) {
if ($PodeContext.Server.IsIIS) {
$Port = [int]$env:ASPNETCORE_PORT
}
if ($PodeContext.Server.IsHeroku) {
$Port = [int]$env:PORT
}
$endpoints = @(foreach ($endpoint in $endpoints) {
if ($endpoint.Port -ne $Port) {
continue
}
$endpoint
})
}
# if we have a protocol, filter
if (![string]::IsNullOrWhiteSpace($Protocol)) {
if ($PodeContext.Server.IsIIS -or $PodeContext.Server.IsHeroku) {
$Protocol = 'Http'
}
$endpoints = @(foreach ($endpoint in $endpoints) {
if ($endpoint.Protocol -ine $Protocol) {
continue
}
$endpoint
})
}
# further filter by endpoint names
if (($null -ne $Name) -and ($Name.Length -gt 0)) {
$endpoints = @(foreach ($_name in $Name) {
foreach ($endpoint in $endpoints) {
if ($endpoint.Name -ine $_name) {
continue
}
$endpoint
}
})
}
# return
return $endpoints
}
<#
.SYNOPSIS
Adds a new Timer with logic to periodically invoke.
.DESCRIPTION
Adds a new Timer with logic to periodically invoke, with options to only run a specific number of times.
.PARAMETER Name
The Name of the Timer.
.PARAMETER Interval
The number of seconds to periodically invoke the Timer's ScriptBlock.
.PARAMETER ScriptBlock
The script for the Timer.
.PARAMETER Limit
The number of times the Timer should be invoked before being removed. (If 0, it will run indefinitely)
.PARAMETER Skip
The number of "invokes" to skip before the Timer actually runs.
.PARAMETER ArgumentList
An array of arguments to supply to the Timer's ScriptBlock.
.PARAMETER FilePath
A literal, or relative, path to a file containing a ScriptBlock for the Timer's logic.
.PARAMETER OnStart
If supplied, the timer will trigger when the server starts.
.EXAMPLE
Add-PodeTimer -Name 'Hello' -Interval 10 -ScriptBlock { 'Hello, world!' | Out-Default }
.EXAMPLE
Add-PodeTimer -Name 'RunOnce' -Interval 1 -Limit 1 -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeTimer -Name 'RunAfter60secs' -Interval 10 -Skip 6 -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeTimer -Name 'Args' -Interval 2 -ScriptBlock { /* logic */ } -ArgumentList 'arg1', 'arg2'
#>
function Add-PodeTimer
{
[CmdletBinding(DefaultParameterSetName='Script')]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true)]
[int]
$Interval,
[Parameter(Mandatory=$true, ParameterSetName='Script')]
[scriptblock]
$ScriptBlock,
[Parameter()]
[int]
$Limit = 0,
[Parameter()]
[int]
$Skip = 0,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$FilePath,
[Parameter()]
[object[]]
$ArgumentList,
[switch]
$OnStart
)
# error if serverless
Test-PodeIsServerless -FunctionName 'Add-PodeTimer' -ThrowError
# ensure the timer doesn't already exist
if ($PodeContext.Timers.ContainsKey($Name)) {
throw "[Timer] $($Name): Timer already defined"
}
# is the interval valid?
if ($Interval -le 0) {
throw "[Timer] $($Name): Interval must be greater than 0"
}
# is the limit valid?
if ($Limit -lt 0) {
throw "[Timer] $($Name): Cannot have a negative limit"
}
# is the skip valid?
if ($Skip -lt 0) {
throw "[Timer] $($Name): Cannot have a negative skip value"
}
# if we have a file path supplied, load that path as a scriptblock
if ($PSCmdlet.ParameterSetName -ieq 'file') {
$ScriptBlock = Convert-PodeFileToScriptBlock -FilePath $FilePath
}
# check if the scriptblock has any using vars
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
# calculate the next tick time (based on Skip)
$NextTriggerTime = [DateTime]::Now.AddSeconds($Interval)
if ($Skip -gt 1) {
$NextTriggerTime = $NextTriggerTime.AddSeconds($Interval * $Skip)
}
# add the timer
$PodeContext.Timers[$Name] = @{
Name = $Name
Interval = $Interval
Limit = $Limit
Count = 0
Skip = $Skip
NextTriggerTime = $NextTriggerTime
Script = $ScriptBlock
UsingVariables = $usingVars
Arguments = $ArgumentList
OnStart = $OnStart
Completed = $false
}
}
<#
.SYNOPSIS
Adhoc invoke a Timer's logic.
.DESCRIPTION
Adhoc invoke a Timer's logic outside of its defined interval. This invocation doesn't count towards the Timer's limit.
.PARAMETER Name
The Name of the Timer.
.EXAMPLE
Invoke-PodeTimer -Name 'timer-name'
#>
function Invoke-PodeTimer
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Name
)
# ensure the timer exists
if (!$PodeContext.Timers.ContainsKey($Name)) {
throw "Timer '$($Name)' does not exist"
}
# run timer logic
Invoke-PodeInternalTimer -Timer ($PodeContext.Timers[$Name])
}
<#
.SYNOPSIS
Removes a specific Timer.
.DESCRIPTION
Removes a specific Timer.
.PARAMETER Name
The Name of Timer to be removed.
.EXAMPLE
Remove-PodeTimer -Name 'SaveState'
#>
function Remove-PodeTimer
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Name
)
$PodeContext.Timers.Remove($Name) | Out-Null
}
<#
.SYNOPSIS
Removes all Timers.
.DESCRIPTION
Removes all Timers.
.EXAMPLE
Clear-PodeTimers
#>
function Clear-PodeTimers
{
[CmdletBinding()]
param()
$PodeContext.Timers.Clear()
}
<#
.SYNOPSIS
Edits an existing Timer.
.DESCRIPTION
Edits an existing Timer's properties, such as interval or scriptblock.
.PARAMETER Name
The Name of the Timer.
.PARAMETER Interval
The new Interval for the Timer in seconds.
.PARAMETER ScriptBlock
The new ScriptBlock for the Timer.
.PARAMETER ArgumentList
Any new Arguments for the Timer.
.EXAMPLE
Edit-PodeTimer -Name 'Hello' -Interval 10
#>
function Edit-PodeTimer
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Name,
[Parameter()]
[int]
$Interval = 0,
[Parameter()]
[scriptblock]
$ScriptBlock,
[Parameter()]
[object[]]
$ArgumentList
)
# ensure the timer exists
if (!$PodeContext.Timers.ContainsKey($Name)) {
throw "Timer '$($Name)' does not exist"
}
$_timer = $PodeContext.Timers[$Name]
# edit interval if supplied
if ($Interval -gt 0) {
$_timer.Interval = $Interval
}
# edit scriptblock if supplied
if (!(Test-PodeIsEmpty $ScriptBlock)) {
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
$_timer.Script = $ScriptBlock
$_timer.UsingVariables = $usingVars
}
# edit arguments if supplied
if (!(Test-PodeIsEmpty $ArgumentList)) {
$_timer.Arguments = $ArgumentList
}
}
<#
.SYNOPSIS
Returns any defined timers.
.DESCRIPTION
Returns any defined timers, with support for filtering.
.PARAMETER Name
Any timer Names to filter the timers.
.EXAMPLE
Get-PodeTimer
.EXAMPLE
Get-PodeTimer -Name Name1, Name2
#>
function Get-PodeTimer
{
[CmdletBinding()]
param(
[Parameter()]
[string[]]
$Name
)
$timers = $PodeContext.Timers.Values
# further filter by timer names
if (($null -ne $Name) -and ($Name.Length -gt 0)) {
$timers = @(foreach ($_name in $Name) {
foreach ($timer in $timers) {
if ($timer.Name -ine $_name) {
continue
}
$timer
}
})
}
# return
return $timers
}
<#
.SYNOPSIS
Adds a new Schedule with logic to periodically invoke, defined using Cron Expressions.
.DESCRIPTION
Adds a new Schedule with logic to periodically invoke, defined using Cron Expressions.
.PARAMETER Name
The Name of the Schedule.
.PARAMETER Cron
One, or an Array, of Cron Expressions to define when the Schedule should trigger.
.PARAMETER ScriptBlock
The script defining the Schedule's logic.
.PARAMETER Limit
The number of times the Schedule should trigger before being removed.
.PARAMETER StartTime
A DateTime for when the Schedule should start triggering.
.PARAMETER EndTime
A DateTime for when the Schedule should stop triggering, and be removed.
.PARAMETER ArgumentList
A hashtable of arguments to supply to the Schedule's ScriptBlock.
.PARAMETER FilePath
A literal, or relative, path to a file containing a ScriptBlock for the Schedule's logic.
.PARAMETER OnStart
If supplied, the schedule will trigger when the server starts, regardless if the cron-expression matches the current time.
.EXAMPLE
Add-PodeSchedule -Name 'RunEveryMinute' -Cron '@minutely' -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeSchedule -Name 'RunEveryTuesday' -Cron '0 0 * * TUE' -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeSchedule -Name 'StartAfter2days' -Cron '@hourly' -StartTime [DateTime]::Now.AddDays(2) -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeSchedule -Name 'Args' -Cron '@minutely' -ScriptBlock { /* logic */ } -ArgumentList @{ Arg1 = 'value' }
#>
function Add-PodeSchedule
{
[CmdletBinding(DefaultParameterSetName='Script')]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true)]
[string[]]
$Cron,
[Parameter(Mandatory=$true, ParameterSetName='Script')]
[scriptblock]
$ScriptBlock,
[Parameter()]
[int]
$Limit = 0,
[Parameter()]
[DateTime]
$StartTime,
[Parameter()]
[DateTime]
$EndTime,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$FilePath,
[Parameter()]
[hashtable]
$ArgumentList,
[switch]
$OnStart
)
# error if serverless
Test-PodeIsServerless -FunctionName 'Add-PodeSchedule' -ThrowError
# ensure the schedule doesn't already exist
if ($PodeContext.Schedules.ContainsKey($Name)) {
throw "[Schedule] $($Name): Schedule already defined"
}
# ensure the limit is valid
if ($Limit -lt 0) {
throw "[Schedule] $($Name): Cannot have a negative limit"
}
# ensure the start/end dates are valid
if (($null -ne $EndTime) -and ($EndTime -lt [DateTime]::Now)) {
throw "[Schedule] $($Name): The EndTime value must be in the future"
}
if (($null -ne $StartTime) -and ($null -ne $EndTime) -and ($EndTime -le $StartTime)) {
throw "[Schedule] $($Name): Cannot have a StartTime after the EndTime"
}
# if we have a file path supplied, load that path as a scriptblock
if ($PSCmdlet.ParameterSetName -ieq 'file') {
$ScriptBlock = Convert-PodeFileToScriptBlock -FilePath $FilePath
}
# check if the scriptblock has any using vars
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
# add the schedule
$parsedCrons = ConvertFrom-PodeCronExpressions -Expressions @($Cron)
$nextTrigger = Get-PodeCronNextEarliestTrigger -Expressions $parsedCrons -StartTime $StartTime -EndTime $EndTime
$PodeContext.Schedules[$Name] = @{
Name = $Name
StartTime = $StartTime
EndTime = $EndTime
Crons = $parsedCrons
CronsRaw = @($Cron)
Limit = $Limit
Count = 0
NextTriggerTime = $nextTrigger
Script = $ScriptBlock
UsingVariables = $usingVars
Arguments = (Protect-PodeValue -Value $ArgumentList -Default @{})
OnStart = $OnStart
Completed = ($null -eq $nextTrigger)
}
}
<#
.SYNOPSIS
Set the maximum number of concurrent schedules.
.DESCRIPTION
Set the maximum number of concurrent schedules.
.PARAMETER Maximum
The Maximum number of schdules to run.
.EXAMPLE
Set-PodeScheduleConcurrency -Maximum 25
#>
function Set-PodeScheduleConcurrency
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[int]
$Maximum
)
# error if <=0
if ($Maximum -le 0) {
throw "Maximum concurrent schedules must be >=1 but got: $($Maximum)"
}
# ensure max > min
$_min = 1
if ($null -ne $PodeContext.RunspacePools.Schedules) {
$_min = $PodeContext.RunspacePools.Schedules.GetMinRunspaces()
}
if ($_min -gt $Maximum) {
throw "Maximum concurrent schedules cannot be less than the minimum of $($_min) but got: $($Maximum)"
}
# set the max schedules
$PodeContext.Threads.Schedules = $Maximum
if ($null -ne $PodeContext.RunspacePools.Schedules) {
$PodeContext.RunspacePools.Schedules.SetMaxRunspaces($Maximum)
}
}
<#
.SYNOPSIS
Adhoc invoke a Schedule's logic.
.DESCRIPTION
Adhoc invoke a Schedule's logic outside of its defined cron-expression. This invocation doesn't count towards the Schedule's limit.
.PARAMETER Name
The Name of the Schedule.
.EXAMPLE
Invoke-PodeSchedule -Name 'schedule-name'
#>
function Invoke-PodeSchedule
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Name
)
# ensure the schedule exists
if (!$PodeContext.Schedules.ContainsKey($Name)) {
throw "Schedule '$($Name)' does not exist"
}
# run schedule logic
Invoke-PodeInternalScheduleLogic -Schedule ($PodeContext.Schedules[$Name])
}
<#
.SYNOPSIS
Removes a specific Schedule.
.DESCRIPTION
Removes a specific Schedule.
.PARAMETER Name
The Name of the Schedule to be removed.
.EXAMPLE
Remove-PodeSchedule -Name 'RenewToken'
#>
function Remove-PodeSchedule
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Name
)
$PodeContext.Schedules.Remove($Name) | Out-Null
}
<#
.SYNOPSIS
Removes all Schedules.
.DESCRIPTION
Removes all Schedules.
.EXAMPLE
Clear-PodeSchedules
#>
function Clear-PodeSchedules
{
[CmdletBinding()]
param()
$PodeContext.Schedules.Clear()
}
<#
.SYNOPSIS
Edits an existing Schedule.
.DESCRIPTION
Edits an existing Schedule's properties, such an cron expressions or scriptblock.
.PARAMETER Name
The Name of the Schedule.
.PARAMETER Cron
Any new Cron Expressions for the Schedule.
.PARAMETER ScriptBlock
The new ScriptBlock for the Schedule.
.PARAMETER ArgumentList
Any new Arguments for the Schedule.
.EXAMPLE
Edit-PodeSchedule -Name 'Hello' -Cron '@minutely'
.EXAMPLE
Edit-PodeSchedule -Name 'Hello' -Cron @('@hourly', '0 0 * * TUE')
#>
function Edit-PodeSchedule
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Name,
[Parameter()]
[string[]]
$Cron,
[Parameter()]
[scriptblock]
$ScriptBlock,
[Parameter()]
[hashtable]
$ArgumentList
)
# ensure the schedule exists
if (!$PodeContext.Schedules.ContainsKey($Name)) {
throw "Schedule '$($Name)' does not exist"
}
$_schedule = $PodeContext.Schedules[$Name]
# edit cron if supplied
if (!(Test-PodeIsEmpty $Cron)) {
$_schedule.Crons = (ConvertFrom-PodeCronExpressions -Expressions @($Cron))
$_schedule.CronsRaw = $Cron
$_schedule.NextTriggerTime = Get-PodeCronNextEarliestTrigger -Expressions $_schedule.Crons -StartTime $_schedule.StartTime -EndTime $_schedule.EndTime
}
# edit scriptblock if supplied
if (!(Test-PodeIsEmpty $ScriptBlock)) {
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
$_schedule.Script = $ScriptBlock
$_schedule.UsingVariables = $usingVars
}
# edit arguments if supplied
if (!(Test-PodeIsEmpty $ArgumentList)) {
$_schedule.Arguments = $ArgumentList
}
}
<#
.SYNOPSIS
Returns any defined schedules.
.DESCRIPTION
Returns any defined schedules, with support for filtering.
.PARAMETER Name
Any schedule Names to filter the schedules.
.PARAMETER StartTime
An optional StartTime to only return Schedules that will trigger after this date.
.PARAMETER EndTime
An optional EndTime to only return Schedules that will trigger before this date.
.EXAMPLE
Get-PodeSchedule
.EXAMPLE
Get-PodeSchedule -Name Name1, Name2
.EXAMPLE
Get-PodeSchedule -Name Name1, Name2 -StartTime [datetime]::new(2020, 3, 1) -EndTime [datetime]::new(2020, 3, 31)
#>
function Get-PodeSchedule
{
[CmdletBinding()]
param(
[Parameter()]
[string[]]
$Name,
[Parameter()]
$StartTime = $null,
[Parameter()]
$EndTime = $null
)
$schedules = $PodeContext.Schedules.Values
# further filter by schedule names
if (($null -ne $Name) -and ($Name.Length -gt 0)) {
$schedules = @(foreach ($_name in $Name) {
foreach ($schedule in $schedules) {
if ($schedule.Name -ine $_name) {
continue
}
$schedule
}
})
}
# filter by some start time
if ($null -ne $StartTime) {
$schedules = @(foreach ($schedule in $schedules) {
if (($null -ne $schedule.StartTime) -and ($StartTime -lt $schedule.StartTime)) {
continue
}
$_end = $EndTime
if ($null -eq $_end) {
$_end = $schedule.EndTime
}
if (($null -ne $schedule.EndTime) -and
(($StartTime -gt $schedule.EndTime) -or
((Get-PodeScheduleNextTrigger -Name $schedule.Name -DateTime $StartTime) -gt $_end))) {
continue
}
$schedule
})
}
# filter by some end time
if ($null -ne $EndTime) {
$schedules = @(foreach ($schedule in $schedules) {
if (($null -ne $schedule.EndTime) -and ($EndTime -gt $schedule.EndTime)) {
continue
}
$_start = $StartTime
if ($null -eq $_start) {
$_start = $schedule.StartTime
}
if (($null -ne $schedule.StartTime) -and
(($EndTime -lt $schedule.StartTime) -or
((Get-PodeScheduleNextTrigger -Name $schedule.Name -DateTime $_start) -gt $EndTime))) {
continue
}
$schedule
})
}
# return
return $schedules
}
<#
.SYNOPSIS
Get the next trigger time for a Schedule.
.DESCRIPTION
Get the next trigger time for a Schedule, either from the Schedule's StartTime or from a defined DateTime.
.PARAMETER Name
The Name of the Schedule.
.PARAMETER DateTime
An optional specific DateTime to get the next trigger time after. This DateTime must be between the Schedule's StartTime and EndTime.
.EXAMPLE
Get-PodeScheduleNextTrigger -Name Schedule1
.EXAMPLE
Get-PodeScheduleNextTrigger -Name Schedule1 -DateTime [datetime]::new(2020, 3, 10)
#>
function Get-PodeScheduleNextTrigger
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Name,
[Parameter()]
$DateTime = $null
)
# ensure the schedule exists
if (!$PodeContext.Schedules.ContainsKey($Name)) {
throw "Schedule '$($Name)' does not exist"
}
$_schedule = $PodeContext.Schedules[$Name]
# ensure date is after start/before end
if (($null -ne $DateTime) -and ($null -ne $_schedule.StartTime) -and ($DateTime -lt $_schedule.StartTime)) {
throw "Supplied date is before the start time of the schedule at $($_schedule.StartTime)"
}
if (($null -ne $DateTime) -and ($null -ne $_schedule.EndTime) -and ($DateTime -gt $_schedule.EndTime)) {
throw "Supplied date is after the end time of the schedule at $($_schedule.EndTime)"
}
# get the next trigger
if ($null -eq $DateTime) {
$DateTime = $_schedule.StartTime
}
return (Get-PodeCronNextEarliestTrigger -Expressions $_schedule.Crons -StartTime $DateTime -EndTime $_schedule.EndTime)
}
<#
.SYNOPSIS
Adds a new Middleware to be invoked before every Route, or certain Routes.
.DESCRIPTION
Adds a new Middleware to be invoked before every Route, or certain Routes.
.PARAMETER Name
The Name of the Middleware.
.PARAMETER ScriptBlock
The Script defining the logic of the Middleware.
.PARAMETER InputObject
A Middleware HashTable from New-PodeMiddleware, or from certain other functions that return Middleware as a HashTable.
.PARAMETER Route
A Route path for which Routes this Middleware should only be invoked against.
.PARAMETER ArgumentList
An array of arguments to supply to the Middleware's ScriptBlock.
.EXAMPLE
Add-PodeMiddleware -Name 'BlockAgents' -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeMiddleware -Name 'CheckEmailOnApi' -Route '/api/*' -ScriptBlock { /* logic */ }
#>
function Add-PodeMiddleware
{
[CmdletBinding(DefaultParameterSetName='Script')]
param(
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ParameterSetName='Script')]
[scriptblock]
$ScriptBlock,
[Parameter(Mandatory=$true, ParameterSetName='Input', ValueFromPipeline=$true)]
[hashtable]
$InputObject,
[Parameter()]
[string]
$Route,
[Parameter()]
[object[]]
$ArgumentList
)
# ensure name doesn't already exist
if (($PodeContext.Server.Middleware | Where-Object { $_.Name -ieq $Name } | Measure-Object).Count -gt 0) {
throw "[Middleware] $($Name): Middleware already defined"
}
# if it's a script - call New-PodeMiddleware
if ($PSCmdlet.ParameterSetName -ieq 'script') {
$InputObject = (New-PodeMiddlewareInternal `
-ScriptBlock $ScriptBlock `
-Route $Route `
-ArgumentList $ArgumentList `
-PSSession $PSCmdlet.SessionState)
}
else {
$Route = ConvertTo-PodeRouteRegex -Path $Route
$InputObject.Route = Protect-PodeValue -Value $Route -Default $InputObject.Route
$InputObject.Options = Protect-PodeValue -Value $Options -Default $InputObject.Options
}
# ensure we have a script to run
if (Test-PodeIsEmpty $InputObject.Logic) {
throw "[Middleware]: No logic supplied in ScriptBlock"
}
# set name, and override route/args
$InputObject.Name = $Name
# add the logic to array of middleware that needs to be run
$PodeContext.Server.Middleware += $InputObject
}
<#
.SYNOPSIS
Creates a new Middleware HashTable object, that can be piped/used in Add-PodeMiddleware or in Routes.
.DESCRIPTION
Creates a new Middleware HashTable object, that can be piped/used in Add-PodeMiddleware or in Routes.
.PARAMETER ScriptBlock
The Script that defines the logic of the Middleware.
.PARAMETER Route
A Route path for which Routes this Middleware should only be invoked against.
.PARAMETER ArgumentList
An array of arguments to supply to the Middleware's ScriptBlock.
.EXAMPLE
New-PodeMiddleware -ScriptBlock { /* logic */ } -ArgumentList 'Email' | Add-PodeMiddleware -Name 'CheckEmail'
#>
function New-PodeMiddleware
{
[CmdletBinding()]
[OutputType([hashtable])]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[scriptblock]
$ScriptBlock,
[Parameter()]
[string]
$Route,
[Parameter()]
[object[]]
$ArgumentList
)
return (New-PodeMiddlewareInternal `
-ScriptBlock $ScriptBlock `
-Route $Route `
-ArgumentList $ArgumentList `
-PSSession $PSCmdlet.SessionState)
}
<#
.SYNOPSIS
Removes a specific user defined Middleware.
.DESCRIPTION
Removes a specific user defined Middleware.
.PARAMETER Name
The Name of the Middleware to be removed.
.EXAMPLE
Remove-PodeMiddleware -Name 'Sessions'
#>
function Remove-PodeMiddleware
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]
$Name
)
$PodeContext.Server.Middleware = @($PodeContext.Server.Middleware | Where-Object { $_.Name -ine $Name })
}
<#
.SYNOPSIS
Removes all user defined Middleware.
.DESCRIPTION
Removes all user defined Middleware.
.EXAMPLE
Clear-PodeMiddleware
#>
function Clear-PodeMiddleware
{
[CmdletBinding()]
param()
$PodeContext.Server.Middleware = @()
}
<#
.SYNOPSIS
Appends a message to the current flash messages stored in the session.
.DESCRIPTION
Appends a message to the current flash messages stored in the session for the supplied name.
The messages per name are stored as an array.
.PARAMETER Name
The name of the flash message to be appended.
.PARAMETER Message
The message to append.
.EXAMPLE
Add-PodeFlashMessage -Name 'error' -Message 'There was an error'
#>
function Add-PodeFlashMessage
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true)]
[string]
$Message
)
# if sessions haven't been setup, error
if (!(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use Flash messages'
}
# append the message against the key
if ($null -eq $WebEvent.Session.Data.Flash) {
$WebEvent.Session.Data.Flash = @{}
}
if ($null -eq $WebEvent.Session.Data.Flash[$Name]) {
$WebEvent.Session.Data.Flash[$Name] = @($Message)
}
else {
$WebEvent.Session.Data.Flash[$Name] += @($Message)
}
}
<#
.SYNOPSIS
Clears all flash messages.
.DESCRIPTION
Clears all of the flash messages currently stored in the session.
.EXAMPLE
Clear-PodeFlashMessages
#>
function Clear-PodeFlashMessages
{
[CmdletBinding()]
param()
# if sessions haven't been setup, error
if (!(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use Flash messages'
}
# clear all keys
if ($null -ne $WebEvent.Session.Data.Flash) {
$WebEvent.Session.Data.Flash = @{}
}
}
<#
.SYNOPSIS
Returns all flash messages stored against a name, and the clears the messages.
.DESCRIPTION
Returns all of the flash messages, as an array, currently stored for the name within the session.
Once retrieved, the messages are removed from storage.
.PARAMETER Name
The name of the flash messages to return.
.EXAMPLE
Get-PodeFlashMessage -Name 'error'
#>
function Get-PodeFlashMessage
{
[CmdletBinding()]
[OutputType([string[]])]
param (
[Parameter(Mandatory=$true)]
[string]
$Name
)
# if sessions haven't been setup, error
if (!(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use Flash messages'
}
# retrieve messages from session, then delete it
if ($null -eq $WebEvent.Session.Data.Flash) {
return @()
}
$v = @($WebEvent.Session.Data.Flash[$Name])
$WebEvent.Session.Data.Flash.Remove($Name)
if (Test-PodeIsEmpty $v) {
return @()
}
return @($v)
}
<#
.SYNOPSIS
Returns all of the names for each of the messages currently being stored.
.DESCRIPTION
Returns all of the names for each of the messages currently being stored. This does not clear the messages.
.EXAMPLE
Get-PodeFlashMessageNames
#>
function Get-PodeFlashMessageNames
{
[CmdletBinding()]
[OutputType([string[]])]
param()
# if sessions haven't been setup, error
if (!(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use Flash messages'
}
# return list of all current keys
if ($null -eq $WebEvent.Session.Data.Flash) {
return @()
}
return @($WebEvent.Session.Data.Flash.Keys)
}
<#
.SYNOPSIS
Removes flash messages for the supplied name currently being stored.
.DESCRIPTION
Removes flash messages for the supplied name currently being stored.
.PARAMETER Name
The name of the flash messages to remove.
.EXAMPLE
Remove-PodeFlashMessage -Name 'error'
#>
function Remove-PodeFlashMessage
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Name
)
# if sessions haven't been setup, error
if (!(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use Flash messages'
}
# remove key from flash messages
if ($null -ne $WebEvent.Session.Data.Flash) {
$WebEvent.Session.Data.Flash.Remove($Name)
}
}
<#
.SYNOPSIS
Tests if there are any flash messages currently being stored for a supplied name.
.DESCRIPTION
Tests if there are any flash messages currently being stored for a supplied name.
.PARAMETER Name
The name of the flash message to check.
.EXAMPLE
Test-PodeFlashMessage -Name 'error'
#>
function Test-PodeFlashMessage
{
[CmdletBinding()]
[OutputType([bool])]
param (
[Parameter(Mandatory=$true)]
[string]
$Name
)
# if sessions haven't been setup, error
if (!(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use Flash messages'
}
# return if a key exists as a flash message
if ($null -eq $WebEvent.Session.Data.Flash) {
return $false
}
return $WebEvent.Session.Data.Flash.ContainsKey($Name)
}
<#
.SYNOPSIS
Adds a Handler of a specific Type.
.DESCRIPTION
Adds a Handler of a specific Type.
.PARAMETER Type
The Type of the Handler.
.PARAMETER Name
The Name of the Handler.
.PARAMETER ScriptBlock
The ScriptBlock for the Handler's main logic.
.PARAMETER FilePath
A literal, or relative, path to a file containing a ScriptBlock for the Handler's main logic.
.PARAMETER ArgumentList
An array of arguments to supply to the Handler's ScriptBlock.
.EXAMPLE
Add-PodeHandler -Type Smtp -Name 'Main' -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeHandler -Type Service -Name 'Looper' -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeHandler -Type Smtp -Name 'Main' -ScriptBlock { /* logic */ } -ArgumentList 'arg1', 'arg2'
#>
function Add-PodeHandler
{
[CmdletBinding(DefaultParameterSetName='Script')]
param (
[Parameter(Mandatory=$true)]
[ValidateSet('Service', 'Smtp', 'Tcp')]
[string]
$Type,
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ParameterSetName='Script')]
[scriptblock]
$ScriptBlock,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$FilePath,
[Parameter()]
[object[]]
$ArgumentList
)
# error if serverless
Test-PodeIsServerless -FunctionName 'Add-PodeHandler' -ThrowError
# ensure handler isn't already set
if ($PodeContext.Server.Handlers[$Type].ContainsKey($Name)) {
throw "[$($Type)] $($Name): Handler already defined"
}
# if we have a file path supplied, load that path as a scriptblock
if ($PSCmdlet.ParameterSetName -ieq 'file') {
# if file doesn't exist, error
if (!(Test-PodePath -Path $FilePath -NoStatus)) {
throw "[$($Type)] $($Name): The FilePath does not exist: $($FilePath)"
}
# if the path is a wildcard or directory, error
if (!(Test-PodePathIsFile -Path $FilePath -FailOnWildcard)) {
throw "[$($Type)] $($Name): The FilePath cannot be a wildcard or directory: $($FilePath)"
}
$ScriptBlock = [scriptblock](Use-PodeScript -Path $FilePath)
}
# check if the scriptblock has any using vars
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
# add the handler
$PodeContext.Server.Handlers[$Type][$Name] += @(@{
Logic = $ScriptBlock
UsingVariables = $usingVars
Arguments = $ArgumentList
})
}
<#
.SYNOPSIS
Remove a specific Handler.
.DESCRIPTION
Remove a specific Handler.
.PARAMETER Type
The type of the Handler to be removed.
.PARAMETER Name
The name of the Handler to be removed.
.EXAMPLE
Remove-PodeHandler -Type Smtp -Name 'Main'
#>
function Remove-PodeHandler
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[ValidateSet('Service', 'Smtp', 'Tcp')]
[string]
$Type,
[Parameter(Mandatory=$true)]
[string]
$Name
)
# ensure handler does exist
if (!$PodeContext.Server.Handlers[$Type].ContainsKey($Name)) {
return
}
# remove the handler
$PodeContext.Server.Handlers[$Type].Remove($Name) | Out-Null
}
<#
.SYNOPSIS
Removes all added Handlers, or Handlers of a specific Type.
.DESCRIPTION
Removes all added Handlers, or Handlers of a specific Type.
.PARAMETER Type
The Type of Handlers to remove.
.EXAMPLE
Clear-PodeHandlers -Type Smtp
#>
function Clear-PodeHandlers
{
[CmdletBinding()]
param (
[Parameter()]
[ValidateSet('', 'Service', 'Smtp', 'Tcp')]
[string]
$Type
)
if (![string]::IsNullOrWhiteSpace($Type)) {
$PodeContext.Server.Handlers[$Type].Clear()
}
else {
$PodeContext.Server.Handlers.Keys.Clone() | ForEach-Object {
$PodeContext.Server.Handlers[$_].Clear()
}
}
}
<#
.SYNOPSIS
Appends a header against the Response.
.DESCRIPTION
Appends a header against the Response. If the current context is serverless, then this function acts like Set-PodeHeader.
.PARAMETER Name
The name of the header.
.PARAMETER Value
The value to set against the header.
.PARAMETER Secret
If supplied, the secret with which to sign the header's value.
.EXAMPLE
Add-PodeHeader -Name 'X-AuthToken' -Value 'AA-BB-CC-33'
#>
function Add-PodeHeader
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true)]
[string]
$Value,
[Parameter()]
[string]
$Secret
)
# sign the value if we have a secret
if (![string]::IsNullOrWhiteSpace($Secret)) {
$Value = (Invoke-PodeValueSign -Value $Value -Secret $Secret)
}
# add the header to the response
if ($PodeContext.Server.IsServerless) {
$WebEvent.Response.Headers[$Name] = $Value
}
else {
$WebEvent.Response.Headers.Add($Name, $Value)
}
}
<#
.SYNOPSIS
Tests if a header is present on the Request.
.DESCRIPTION
Tests if a header is present on the Request.
.PARAMETER Name
The name of the header to test.
.EXAMPLE
Test-PodeHeader -Name 'X-AuthToken'
#>
function Test-PodeHeader
{
[CmdletBinding()]
[OutputType([bool])]
param (
[Parameter(Mandatory=$true)]
[string]
$Name
)
$header = (Get-PodeHeader -Name $Name)
return (![string]::IsNullOrWhiteSpace($header))
}
<#
.SYNOPSIS
Retrieves the value of a header from the Request.
.DESCRIPTION
Retrieves the value of a header from the Request.
.PARAMETER Name
The name of the header to retrieve.
.PARAMETER Secret
The secret used to unsign the header's value.
.EXAMPLE
Get-PodeHeader -Name 'X-AuthToken'
#>
function Get-PodeHeader
{
[CmdletBinding()]
[OutputType([string])]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter()]
[string]
$Secret
)
# get the value for the header from the request
$header = $WebEvent.Request.Headers.$Name
# if a secret was supplied, attempt to unsign the header's value
if (![string]::IsNullOrWhiteSpace($Secret)) {
$header = (Invoke-PodeValueUnsign -Value $header -Secret $Secret)
}
return $header
}
<#
.SYNOPSIS
Sets a header on the Response, clearing all current values for the header.
.DESCRIPTION
Sets a header on the Response, clearing all current values for the header.
.PARAMETER Name
The name of the header.
.PARAMETER Value
The value to set against the header.
.PARAMETER Secret
If supplied, the secret with which to sign the header's value.
.EXAMPLE
Set-PodeHeader -Name 'X-AuthToken' -Value 'AA-BB-CC-33'
#>
function Set-PodeHeader
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true)]
[string]
$Value,
[Parameter()]
[string]
$Secret
)
# sign the value if we have a secret
if (![string]::IsNullOrWhiteSpace($Secret)) {
$Value = (Invoke-PodeValueSign -Value $Value -Secret $Secret)
}
# set the header on the response
if ($PodeContext.Server.IsServerless) {
$WebEvent.Response.Headers[$Name] = $Value
}
else {
$WebEvent.Response.Headers.Set($Name, $Value)
}
}
<#
.SYNOPSIS
Tests if a header on the Request is validly signed.
.DESCRIPTION
Tests if a header on the Request is validly signed, by attempting to unsign it using some secret.
.PARAMETER Name
The name of the header to test.
.PARAMETER Secret
A secret to use for attempting to unsign the header's value.
.EXAMPLE
Test-PodeHeaderSigned -Name 'X-Header-Name' -Secret 'hunter2'
#>
function Test-PodeHeaderSigned
{
[CmdletBinding()]
[OutputType([bool])]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter()]
[string]
$Secret
)
$header = Get-PodeHeader -Name $Name
if ([string]::IsNullOrWhiteSpace($header)) {
return $false
}
$value = (Invoke-PodeValueUnsign -Value $header -Secret $Secret)
return (![string]::IsNullOrWhiteSpace($value))
}
<#
.SYNOPSIS
Create a new method of outputting logs.
.DESCRIPTION
Create a new method of outputting logs.
.PARAMETER Terminal
If supplied, will use the inbuilt Terminal logging output method.
.PARAMETER File
If supplied, will use the inbuilt File logging output method.
.PARAMETER Path
The File Path of where to store the logs.
.PARAMETER Name
The File Name to prepend new log files using.
.PARAMETER Batch
An optional batch size to write log items in bulk (Default: 1)
.PARAMETER BatchTimeout
An optional batch timeout, in seconds, to send items off for writing if a log item isn't received (Default: 0)
.PARAMETER MaxDays
The maximum number of days to keep logs, before Pode automatically removes them.
.PARAMETER MaxSize
The maximum size of a log file, before Pode starts writing to a new log file.
.PARAMETER Custom
If supplied, will allow you to create a Custom Logging output method.
.PARAMETER ScriptBlock
The ScriptBlock that defines how to output a log item.
.PARAMETER ArgumentList
An array of arguments to supply to the Custom Logging output method's ScriptBlock.
.EXAMPLE
$term_logging = New-PodeLoggingMethod -Terminal
.EXAMPLE
$file_logging = New-PodeLoggingMethod -File -Path ./logs -Name 'requests'
.EXAMPLE
$custom_logging = New-PodeLoggingMethod -Custom -ScriptBlock { /* logic */ }
#>
function New-PodeLoggingMethod
{
[CmdletBinding(DefaultParameterSetName='Terminal')]
[OutputType([hashtable])]
param (
[Parameter(ParameterSetName='Terminal')]
[switch]
$Terminal,
[Parameter(ParameterSetName='File')]
[switch]
$File,
[Parameter(ParameterSetName='File')]
[string]
$Path = './logs',
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$Name,
[Parameter()]
[int]
$Batch = 1,
[Parameter()]
[int]
$BatchTimeout = 0,
[Parameter(ParameterSetName='File')]
[ValidateScript({
if ($_ -lt 0) {
throw "MaxDays must be 0 or greater, but got: $($_)s"
}
return $true
})]
[int]
$MaxDays = 0,
[Parameter(ParameterSetName='File')]
[ValidateScript({
if ($_ -lt 0) {
throw "MaxSize must be 0 or greater, but got: $($_)s"
}
return $true
})]
[int]
$MaxSize = 0,
[Parameter(ParameterSetName='Custom')]
[switch]
$Custom,
[Parameter(Mandatory=$true, ParameterSetName='Custom')]
[ValidateScript({
if (Test-PodeIsEmpty $_) {
throw "A non-empty ScriptBlock is required for the Custom logging output method"
}
return $true
})]
[scriptblock]
$ScriptBlock,
[Parameter(ParameterSetName='Custom')]
[object[]]
$ArgumentList
)
# batch details
$batchInfo = @{
Size = $Batch
Timeout = $BatchTimeout
LastUpdate = $null
Items = @()
}
# return info on appropriate logging type
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'terminal' {
return @{
ScriptBlock = (Get-PodeLoggingTerminalMethod)
Batch = $batchInfo
Arguments = @{}
}
}
'file' {
$Path = (Protect-PodeValue -Value $Path -Default './logs')
$Path = (Get-PodeRelativePath -Path $Path -JoinRoot)
New-Item -Path $Path -ItemType Directory -Force | Out-Null
return @{
ScriptBlock = (Get-PodeLoggingFileMethod)
Batch = $batchInfo
Arguments = @{
Name = $Name
Path = $Path
MaxDays = $MaxDays
MaxSize = $MaxSize
FileId = 0
Date = $null
NextClearDown = [datetime]::Now.Date
}
}
}
'custom' {
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
return @{
ScriptBlock = $ScriptBlock
UsingVariables = $usingVars
Batch = $batchInfo
Arguments = $ArgumentList
}
}
}
}
<#
.SYNOPSIS
Enables Request Logging using a supplied output method.
.DESCRIPTION
Enables Request Logging using a supplied output method.
.PARAMETER Method
The Method to use for output the log entry (From New-PodeLoggingMethod).
.PARAMETER Raw
If supplied, the log item returned will be the raw Request item as a hashtable and not a string (for Custom methods).
.EXAMPLE
New-PodeLoggingMethod -Terminal | Enable-PodeRequestLogging
#>
function Enable-PodeRequestLogging
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$Method,
[switch]
$Raw
)
Test-PodeIsServerless -FunctionName 'Enable-PodeRequestLogging' -ThrowError
$name = Get-PodeRequestLoggingName
# error if it's already enabled
if ($PodeContext.Server.Logging.Types.Contains($name)) {
throw 'Request Logging has already been enabled'
}
# ensure the Method contains a scriptblock
if (Test-PodeIsEmpty $Method.ScriptBlock) {
throw "The supplied output Method for Request Logging requires a valid ScriptBlock"
}
# add the request logger
$PodeContext.Server.Logging.Types[$name] = @{
Method = $Method
ScriptBlock = (Get-PodeLoggingInbuiltType -Type Requests)
Arguments = @{
Raw = $Raw
}
}
}
<#
.SYNOPSIS
Disables Request Logging.
.DESCRIPTION
Disables Request Logging.
.EXAMPLE
Disable-PodeRequestLogging
#>
function Disable-PodeRequestLogging
{
[CmdletBinding()]
param()
Remove-PodeLogger -Name (Get-PodeRequestLoggingName)
}
<#
.SYNOPSIS
Enables Error Logging using a supplied output method.
.DESCRIPTION
Enables Error Logging using a supplied output method.
.PARAMETER Method
The Method to use for output the log entry (From New-PodeLoggingMethod).
.PARAMETER Levels
The Levels of errors that should be logged (default is Error).
.PARAMETER Raw
If supplied, the log item returned will be the raw Error item as a hashtable and not a string (for Custom methods).
.EXAMPLE
New-PodeLoggingMethod -Terminal | Enable-PodeErrorLogging
#>
function Enable-PodeErrorLogging
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$Method,
[Parameter()]
[ValidateNotNullOrEmpty()]
[ValidateSet('Error', 'Warning', 'Informational', 'Verbose', 'Debug')]
[string[]]
$Levels = @('Error'),
[switch]
$Raw
)
$name = Get-PodeErrorLoggingName
# error if it's already enabled
if ($PodeContext.Server.Logging.Types.Contains($name)) {
throw 'Error Logging has already been enabled'
}
# ensure the Method contains a scriptblock
if (Test-PodeIsEmpty $Method.ScriptBlock) {
throw "The supplied output Method for Error Logging requires a valid ScriptBlock"
}
# add the error logger
$PodeContext.Server.Logging.Types[$name] = @{
Method = $Method
ScriptBlock = (Get-PodeLoggingInbuiltType -Type Errors)
Arguments = @{
Raw = $Raw
Levels = $Levels
}
}
}
<#
.SYNOPSIS
Disables Error Logging.
.DESCRIPTION
Disables Error Logging.
.EXAMPLE
Disable-PodeErrorLogging
#>
function Disable-PodeErrorLogging
{
[CmdletBinding()]
param()
Remove-PodeLogger -Name (Get-PodeErrorLoggingName)
}
<#
.SYNOPSIS
Adds a custom Logging method for parsing custom log items.
.DESCRIPTION
Adds a custom Logging method for parsing custom log items.
.PARAMETER Name
A unique Name for the Logging method.
.PARAMETER Method
The Method to use for output the log entry (From New-PodeLoggingMethod).
.PARAMETER ScriptBlock
The ScriptBlock defining logic that transforms an item, and returns it for outputting.
.PARAMETER ArgumentList
An array of arguments to supply to the Custom Logger's ScriptBlock.
.EXAMPLE
New-PodeLoggingMethod -Terminal | Add-PodeLogger -Name 'Main' -ScriptBlock { /* logic */ }
#>
function Add-PodeLogger
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$Method,
[Parameter(Mandatory=$true)]
[ValidateScript({
if (Test-PodeIsEmpty $_) {
throw "A non-empty ScriptBlock is required for the logging method"
}
return $true
})]
[scriptblock]
$ScriptBlock,
[Parameter()]
[object[]]
$ArgumentList
)
# ensure the name doesn't already exist
if ($PodeContext.Server.Logging.Types.ContainsKey($Name)) {
throw "Logging method already defined: $($Name)"
}
# ensure the Method contains a scriptblock
if (Test-PodeIsEmpty $Method.ScriptBlock) {
throw "The supplied output Method for the '$($Name)' Logging method requires a valid ScriptBlock"
}
# check if the scriptblock has any using vars
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
# add logging method to server
$PodeContext.Server.Logging.Types[$Name] = @{
Method = $Method
ScriptBlock = $ScriptBlock
UsingVariables = $usingVars
Arguments = $ArgumentList
}
}
<#
.SYNOPSIS
Removes a configured Logging method.
.DESCRIPTION
Removes a configured Logging method.
.PARAMETER Name
The Name of the Logging method.
.EXAMPLE
Remove-PodeLogger -Name 'LogName'
#>
function Remove-PodeLogger
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Name
)
$PodeContext.Server.Logging.Types.Remove($Name) | Out-Null
}
<#
.SYNOPSIS
Clears all Logging methods that have been configured.
.DESCRIPTION
Clears all Logging methods that have been configured.
.EXAMPLE
Clear-PodeLoggers
#>
function Clear-PodeLoggers
{
[CmdletBinding()]
param()
$PodeContext.Server.Logging.Types.Clear()
}
<#
.SYNOPSIS
Writes and Exception or ErrorRecord using the inbuilt error logging.
.DESCRIPTION
Writes and Exception or ErrorRecord using the inbuilt error logging.
.PARAMETER Exception
An Exception to write.
.PARAMETER ErrorRecord
An ErrorRecord to write.
.PARAMETER Level
The Level of the error being logged.
.PARAMETER CheckInnerException
If supplied, any exceptions are check for inner exceptions. If one is present, this is also logged.
.EXAMPLE
try { /* logic */ } catch { $_ | Write-PodeErrorLog }
.EXAMPLE
[System.Exception]::new('error message') | Write-PodeErrorLog
#>
function Write-PodeErrorLog
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true, ParameterSetName='Exception')]
[System.Exception]
$Exception,
[Parameter(Mandatory=$true, ValueFromPipeline=$true, ParameterSetName='Error')]
[System.Management.Automation.ErrorRecord]
$ErrorRecord,
[Parameter()]
[ValidateNotNullOrEmpty()]
[ValidateSet('Error', 'Warning', 'Informational', 'Verbose', 'Debug')]
[string]
$Level = 'Error',
[Parameter(ParameterSetName='Exception')]
[switch]
$CheckInnerException
)
# do nothing if logging is disabled, or error logging isn't setup
$name = Get-PodeErrorLoggingName
if (!(Test-PodeLoggerEnabled -Name $name)) {
return
}
# do nothing if the error level isn't present
$_args = (Get-PodeLogger -Name $name).Arguments
if (@($_args.Levels) -inotcontains $Level) {
return
}
# build error object for what we need
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'exception' {
$item = @{
Category = $Exception.Source
Message = $Exception.Message
StackTrace = $Exception.StackTrace
}
}
'error' {
$item = @{
Category = $ErrorRecord.CategoryInfo.ToString()
Message = $ErrorRecord.Exception.Message
StackTrace = $ErrorRecord.ScriptStackTrace
}
}
}
# add general info
$item['Server'] = $PodeContext.Server.ComputerName
$item['Level'] = $Level
$item['Date'] = [datetime]::Now
$item['ThreadId'] = [int]$ThreadId
# add the item to be processed
$PodeContext.LogsToProcess.Add(@{
Name = $name
Item = $item
}) | Out-Null
# for exceptions, check the inner exception
if ($CheckInnerException -and ($null -ne $Exception.InnerException) -and ![string]::IsNullOrWhiteSpace($Exception.InnerException.Message)) {
$Exception.InnerException | Write-PodeErrorLog
}
}
<#
.SYNOPSIS
Write an object to a configured custom Logging method.
.DESCRIPTION
Write an object to a configured custom Logging method.
.PARAMETER Name
The Name of the Logging method.
.PARAMETER InputObject
The Object to write.
.EXAMPLE
$object | Write-PodeLog -Name 'LogName'
#>
function Write-PodeLog
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[object]
$InputObject
)
# do nothing if logging is disabled, or logger isn't setup
if (!(Test-PodeLoggerEnabled -Name $Name)) {
return
}
# add the item to be processed
$PodeContext.LogsToProcess.Add(@{
Name = $Name
Item = $InputObject
}) | Out-Null
}
<#
.SYNOPSIS
Masks values within a log item to protect sensitive information.
.DESCRIPTION
Masks values within a log item, or any string, to protect sensitive information.
Patterns, and the Mask, can be configured via the server.psd1 configuration file.
.PARAMETER Item
The string Item to mask values.
.EXAMPLE
$value = Protect-PodeLogItem -Item 'Username=Morty, Password=Hunter2'
#>
function Protect-PodeLogItem
{
[CmdletBinding()]
param(
[Parameter(ValueFromPipeline=$true)]
[string]
$Item
)
# do nothing if there are no masks
if (Test-PodeIsEmpty $PodeContext.Server.Logging.Masking.Patterns) {
return $item
}
# attempt to apply each mask
foreach ($mask in $PodeContext.Server.Logging.Masking.Patterns) {
if ($Item -imatch $mask) {
# has both keep before/after
if ($Matches.ContainsKey('keep_before') -and $Matches.ContainsKey('keep_after')) {
$Item = ($Item -ireplace $mask, "`${keep_before}$($PodeContext.Server.Logging.Masking.Mask)`${keep_after}")
}
# has just keep before
elseif ($Matches.ContainsKey('keep_before')) {
$Item = ($Item -ireplace $mask, "`${keep_before}$($PodeContext.Server.Logging.Masking.Mask)")
}
# has just keep after
elseif ($Matches.ContainsKey('keep_after')) {
$Item = ($Item -ireplace $mask, "$($PodeContext.Server.Logging.Masking.Mask)`${keep_after}")
}
# normal mask
else {
$Item = ($Item -ireplace $mask, $PodeContext.Server.Logging.Masking.Mask)
}
}
}
return $Item
}
<#
.SYNOPSIS
Returns the uptime of the server in milliseconds.
.DESCRIPTION
Returns the uptime of the server in milliseconds. You can optionally return the total uptime regardless of server restarts.
.PARAMETER Total
If supplied, the total uptime of the server will be returned, regardless of restarts.
.EXAMPLE
$currentUptime = Get-PodeServerUptime
.EXAMPLE
$totalUptime = Get-PodeServerUptime -Total
#>
function Get-PodeServerUptime
{
[CmdletBinding()]
param(
[switch]
$Total
)
$time = $PodeContext.Metrics.Server.StartTime
if ($Total) {
$time = $PodeContext.Metrics.Server.InitialLoadTime
}
return [long]([datetime]::UtcNow - $time).TotalMilliseconds
}
<#
.SYNOPSIS
Returns the number of times the server has restarted.
.DESCRIPTION
Returns the number of times the server has restarted.
.EXAMPLE
$restarts = Get-PodeServerRestartCount
#>
function Get-PodeServerRestartCount
{
[CmdletBinding()]
param()
return $PodeContext.Metrics.Server.RestartCount
}
<#
.SYNOPSIS
Returns the total number of requests/per status code the Server has receieved.
.DESCRIPTION
Returns the total number of requests/per status code the Server has receieved.
.PARAMETER StatusCode
If supplied, will return the total number of requests for a specific StatusCode.
.PARAMETER Total
If supplied, will return the Total number of Requests.
.EXAMPLE
$totalReqs = Get-PodeServerRequestMetric -Total
.EXAMPLE
$statusReqs = Get-PodeServerRequestMetric
.EXAMPLE
$404Reqs = Get-PodeServerRequestMetric -StatusCode 404
#>
function Get-PodeServerRequestMetric
{
[CmdletBinding(DefaultParameterSetName='StatusCode')]
param(
[Parameter(ParameterSetName='StatusCode')]
[int]
$StatusCode = 0,
[Parameter(ParameterSetName='Total')]
[switch]
$Total
)
if ($Total) {
return $PodeContext.Metrics.Requests.Total
}
if (($StatusCode -le 0)) {
return $PodeContext.Metrics.Requests.StatusCodes
}
$strCode = "$($StatusCode)"
if (!$PodeContext.Metrics.Requests.StatusCodes.ContainsKey($strCode)) {
return 0
}
return $PodeContext.Metrics.Requests.StatusCodes[$strCode]
}
<#
.SYNOPSIS
Adds an access rule to allow or deny IP addresses.
.DESCRIPTION
Adds an access rule to allow or deny IP addresses.
.PARAMETER Access
The type of access to enable.
.PARAMETER Type
What type of request are we configuring?
.PARAMETER Values
A single, or an array of values.
.EXAMPLE
Add-PodeAccessRule -Access Allow -Type IP -Values '127.0.0.1'
.EXAMPLE
Add-PodeAccessRule -Access Deny -Type IP -Values @('192.168.1.1', '10.10.1.0/24')
#>
function Add-PodeAccessRule
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[ValidateSet('Allow', 'Deny')]
[string]
$Access,
[Parameter(Mandatory=$true)]
[ValidateSet('IP')]
[string]
$Type,
[Parameter(Mandatory=$true)]
[string[]]
$Values
)
# error if serverless
Test-PodeIsServerless -FunctionName 'Add-PodeAccessRule' -ThrowError
# call the appropriate access method
switch ($Type.ToLowerInvariant())
{
'ip' {
foreach ($ip in $Values) {
Add-PodeIPAccess -Access $Access -IP $ip
}
}
}
}
<#
.SYNOPSIS
Adds rate limiting rules for an IP addresses, Routes, or Endpoints.
.DESCRIPTION
Adds rate limiting rules for an IP addresses, Routes, or Endpoints.
.PARAMETER Type
What type of request is being rate limited: IP, Route, or Endpoint?
.PARAMETER Values
A single, or an array of values.
.PARAMETER Limit
The maximum number of requests to allow.
.PARAMETER Seconds
The number of seconds to count requests before restarting the count.
.PARAMETER Group
If supplied, groups of IPs in a subnet will be considered as one IP.
.EXAMPLE
Add-PodeLimitRule -Type IP -Values '127.0.0.1' -Limit 10 -Seconds 1
.EXAMPLE
Add-PodeLimitRule -Type IP -Values @('192.168.1.1', '10.10.1.0/24') -Limit 50 -Seconds 1 -Group
.EXAMPLE
Add-PodeLimitRule -Type Route -Values '/downloads' -Limit 5 -Seconds 1
#>
function Add-PodeLimitRule
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[ValidateSet('IP', 'Route', 'Endpoint')]
[string]
$Type,
[Parameter(Mandatory=$true)]
[string[]]
$Values,
[Parameter(Mandatory=$true)]
[int]
$Limit,
[Parameter(Mandatory=$true)]
[int]
$Seconds,
[switch]
$Group
)
# call the appropriate limit method
foreach ($value in $Values)
{
switch ($Type.ToLowerInvariant())
{
'ip' {
Test-PodeIsServerless -FunctionName 'Add-PodeLimitRule' -ThrowError
Add-PodeIPLimit -IP $value -Limit $Limit -Seconds $Seconds -Group:$Group
}
'route' {
Add-PodeRouteLimit -Path $value -Limit $Limit -Seconds $Seconds -Group:$Group
}
'endpoint' {
Add-PodeEndpointLimit -EndpointName $value -Limit $Limit -Seconds $Seconds -Group:$Group
}
}
}
}
<#
.SYNOPSIS
Enables Middleware for creating, retrieving and using Sessions within Pode.
.DESCRIPTION
Enables Middleware for creating, retrieving and using Sessions within Pode. With support for defining Session duration, and custom Storage.
.PARAMETER Secret
A secret to use when signing Sessions.
.PARAMETER Name
The name of the cookie/header used for the Session.
.PARAMETER Duration
The duration a Session should last for, before being expired.
.PARAMETER Generator
A custom ScriptBlock to generate a random unique SessionId. The value returned must be a String.
.PARAMETER Storage
A custom PSObject that defines methods for Delete, Get, and Set. This allow you to store Sessions in custom Storage such as Redis.
.PARAMETER Extend
If supplied, the Sessions will have their durations extended on each successful Request.
.PARAMETER HttpOnly
If supplied, the Session cookie will only be accessible to browsers.
.PARAMETER Secure
If supplied, the Session cookie will only be accessible over HTTPS Requests.
.PARAMETER Strict
If supplied, the supplie Secret will be extended using the client request's UserAgent and RemoteIPAddress.
.PARAMETER UseHeaders
If supplied, Sessions will be sent back in a header on the Response with the Name supplied.
.EXAMPLE
Enable-PodeSessionMiddleware -Secret 'schwifty' -Duration 120
.EXAMPLE
Enable-PodeSessionMiddleware -Secret 'schwifty' -Duration 120 -Extend -Generator { return [System.IO.Path]::GetRandomFileName() }
.EXAMPLE
Enable-PodeSessionMiddleware -Secret 'schwifty' -Duration 120 -UseHeaders -Strict
#>
function Enable-PodeSessionMiddleware
{
[CmdletBinding(DefaultParameterSetName='Cookies')]
param (
[Parameter(Mandatory=$true)]
[string]
$Secret,
[Parameter()]
[ValidateNotNullOrEmpty()]
[string]
$Name = 'pode.sid',
[Parameter()]
[ValidateScript({
if ($_ -lt 0) {
throw "Duration must be 0 or greater, but got: $($_)s"
}
return $true
})]
[int]
$Duration = 0,
[Parameter()]
[scriptblock]
$Generator,
[Parameter()]
[psobject]
$Storage,
[switch]
$Extend,
[Parameter(ParameterSetName='Cookies')]
[switch]
$HttpOnly,
[Parameter(ParameterSetName='Cookies')]
[switch]
$Secure,
[switch]
$Strict,
[Parameter(ParameterSetName='Headers')]
[switch]
$UseHeaders
)
# check that session logic hasn't already been initialised
if (Test-PodeSessionsConfigured) {
throw 'Session Middleware has already been intialised'
}
# ensure the override store has the required methods
if (!(Test-PodeIsEmpty $Storage)) {
$members = @($Storage | Get-Member | Select-Object -ExpandProperty Name)
@('delete', 'get', 'set') | ForEach-Object {
if ($members -inotcontains $_) {
throw "Custom session storage does not implement the required '$($_)()' method"
}
}
}
# if no custom storage, use the inmem one
if (Test-PodeIsEmpty $Storage) {
$Storage = (Get-PodeSessionInMemStore)
Set-PodeSessionInMemClearDown
}
# set options against server context
$PodeContext.Server.Sessions = @{
Name = $Name
Secret = $Secret
GenerateId = (Protect-PodeValue -Value $Generator -Default { return (New-PodeGuid) })
Store = $Storage
Info = @{
Duration = $Duration
Extend = $Extend
Secure = $Secure
Strict = $Strict
HttpOnly = $HttpOnly
UseHeaders = $UseHeaders
}
}
# return scriptblock for the session middleware
$script = Get-PodeSessionMiddleware
(New-PodeMiddleware -ScriptBlock $script) | Add-PodeMiddleware -Name '__pode_mw_sessions__'
}
<#
.SYNOPSIS
Remove the current Session, logging it out.
.DESCRIPTION
Remove the current Session, logging it out. This will remove the session from Storage, and Cookies.
.EXAMPLE
Remove-PodeSession
#>
function Remove-PodeSession
{
[CmdletBinding()]
param()
# if sessions haven't been setup, error
if (!(Test-PodeSessionsConfigured)) {
throw 'Sessions have not been configured'
}
# error if session is null
if ($null -eq $WebEvent.Session) {
return
}
# remove the session, and from auth and cookies
Remove-PodeAuthSession
}
<#
.SYNOPSIS
Saves the current Session's data.
.DESCRIPTION
Saves the current Session's data.
.PARAMETER Force
If supplied, the data will be saved even if nothing has changed.
.EXAMPLE
Save-PodeSession -Force
#>
function Save-PodeSession
{
[CmdletBinding()]
param(
[switch]
$Force
)
# if sessions haven't been setup, error
if (!(Test-PodeSessionsConfigured)) {
throw 'Sessions have not been configured'
}
# error if session is null
if ($null -eq $WebEvent.Session) {
throw 'There is no session available to save'
}
# if auth is in use, then assign to session store
if (!(Test-PodeIsEmpty $WebEvent.Auth) -and $WebEvent.Auth.Store) {
$WebEvent.Session.Data.Auth = $WebEvent.Auth
}
# save the session
Invoke-PodeScriptBlock -ScriptBlock $WebEvent.Session.Save -Arguments @($WebEvent.Session, $Force) -Splat
}
<#
.SYNOPSIS
Returns the currently authenticated SessionId.
.DESCRIPTION
Returns the currently authenticated SessionId. If there's no session, or it's not authenticated, then null is returned instead.
You can also have the SessionId returned as signed as well.
.PARAMETER Signed
If supplied, the returned SessionId will also be signed.
.EXAMPLE
$sessionId = Get-PodeSessionId
#>
function Get-PodeSessionId
{
[CmdletBinding()]
param(
[switch]
$Signed
)
$sessionId = $null
# only return session if authenticated
if (!(Test-PodeIsEmpty $WebEvent.Session.Data.Auth.User) -and $WebEvent.Session.Data.Auth.IsAuthenticated) {
$sessionId = $WebEvent.Session.Id
# do they want the session signed?
if ($Signed) {
$strict = $PodeContext.Server.Sessions.Info.Strict
$secret = $PodeContext.Server.Sessions.Secret
# covert secret to strict mode
if ($strict) {
$secret = ConvertTo-PodeSessionStrictSecret -Secret $secret
}
# sign the value if we have a secret
$sessionId = (Invoke-PodeValueSign -Value $sessionId -Secret $secret)
}
}
return $sessionId
}
<#
.SYNOPSIS
Creates and returns a new secure token for use with CSRF.
.DESCRIPTION
Creates and returns a new secure token for use with CSRF.
.EXAMPLE
$token = New-PodeCsrfToken
#>
function New-PodeCsrfToken
{
[CmdletBinding()]
[OutputType([string])]
param()
# fail if the csrf logic hasn't been initialised
if (!(Test-PodeCsrfConfigured)) {
throw 'CSRF Middleware has not been initialised'
}
# generate a new secret and salt
$Secret = New-PodeCsrfSecret
$Salt = (New-PodeSalt -Length 8)
# return a new token
return "t:$($Salt).$(Invoke-PodeSHA256Hash -Value "$($Salt)-$($Secret)")"
}
<#
.SYNOPSIS
Returns adhoc CSRF CSRF verification Middleware, for use on Routes.
.DESCRIPTION
Returns adhoc CSRF CSRF verification Middleware, for use on Routes.
.EXAMPLE
$csrf = Get-PodeCsrfMiddleware
Add-PodeRoute -Method Get -Path '/cpu' -Middleware $csrf -ScriptBlock { /* logic */ }
#>
function Get-PodeCsrfMiddleware
{
[CmdletBinding()]
[OutputType([hashtable])]
param()
# fail if the csrf logic hasn't been initialised
if (!(Test-PodeCsrfConfigured)) {
throw 'CSRF Middleware has not been initialised'
}
# return scriptblock for the csrf route middleware to test tokens
$script = {
# if there's not a secret, generate and store it
$secret = New-PodeCsrfSecret
# verify the token on the request, if invalid, throw a 403
$token = Get-PodeCsrfToken
if (!(Test-PodeCsrfToken -Secret $secret -Token $token)){
Set-PodeResponseStatus -Code 403 -Description 'Invalid CSRF Token'
return $false
}
# token is valid, move along
return $true
}
return (New-PodeMiddleware -ScriptBlock $script)
}
<#
.SYNOPSIS
Initialises CSRF within Pode for adhoc usage.
.DESCRIPTION
Initialises CSRF within Pode for adhoc usage, with configurable HTTP methods to ignore verification.
.PARAMETER IgnoreMethods
An array of HTTP methods to ignore CSRF verification.
.PARAMETER Secret
A secret to use when signing cookies - for when using CSRF with cookies.
.PARAMETER UseCookies
If supplied, CSRF will used cookies rather than sessions.
.EXAMPLE
Initialize-PodeCsrf -IgnoreMethods @('Get', 'Trace')
.EXAMPLE
Initialize-PodeCsrf -Secret 'some-secret' -UseCookies
#>
function Initialize-PodeCsrf
{
[CmdletBinding()]
param (
[Parameter()]
[ValidateSet('Delete', 'Get', 'Head', 'Merge', 'Options', 'Patch', 'Post', 'Put', 'Trace')]
[string[]]
$IgnoreMethods = @('Get', 'Head', 'Options', 'Trace'),
[Parameter()]
[string]
$Secret,
[switch]
$UseCookies
)
# check that csrf logic hasn't already been intialised
if (Test-PodeCsrfConfigured) {
return
}
# if sessions haven't been setup and we're not using cookies, error
if (!$UseCookies -and !(Test-PodeSessionsConfigured)) {
throw 'Sessions are required to use CSRF unless you want to use cookies'
}
# if we're using cookies, ensure a global secret exists
if ($UseCookies) {
$Secret = (Protect-PodeValue -Value $Secret -Default (Get-PodeCookieSecret -Global))
if (Test-PodeIsEmpty $Secret) {
throw "When using cookies for CSRF, a Secret is required. You can either supply a Secret, or set the Cookie global secret - (Set-PodeCookieSecret '<value>' -Global)"
}
}
# set the options against the server context
$PodeContext.Server.Cookies.Csrf = @{
Name = 'pode.csrf'
UseCookies = $UseCookies
Secret = $Secret
IgnoredMethods = $IgnoreMethods
}
}
<#
.SYNOPSIS
Enables Middleware for verifying CSRF tokens on Requests.
.DESCRIPTION
Enables Middleware for verifying CSRF tokens on Requests, with configurable HTTP methods to ignore verification.
.PARAMETER IgnoreMethods
An array of HTTP methods to ignore CSRF verification.
.PARAMETER Secret
A secret to use when signing cookies - for when using CSRF with cookies.
.PARAMETER UseCookies
If supplied, CSRF will used cookies rather than sessions.
.EXAMPLE
Enable-PodeCsrfMiddleware -IgnoreMethods @('Get', 'Trace')
.EXAMPLE
Enable-PodeCsrfMiddleware -Secret 'some-secret' -UseCookies
#>
function Enable-PodeCsrfMiddleware
{
[CmdletBinding()]
param (
[Parameter()]
[ValidateSet('Delete', 'Get', 'Head', 'Merge', 'Options', 'Patch', 'Post', 'Put', 'Trace')]
[string[]]
$IgnoreMethods = @('Get', 'Head', 'Options', 'Trace'),
[Parameter(ParameterSetName='Cookies')]
[string]
$Secret,
[Parameter(ParameterSetName='Cookies')]
[switch]
$UseCookies
)
Initialize-PodeCsrf -IgnoreMethods $IgnoreMethods -Secret $Secret -UseCookies:$UseCookies
# return scriptblock for the csrf middleware
$script = {
# if the current route method is ignored, just return
$ignored = @($PodeContext.Server.Cookies.Csrf.IgnoredMethods)
if (!(Test-PodeIsEmpty $ignored) -and ($ignored -icontains $WebEvent.Method)) {
return $true
}
# if there's not a secret, generate and store it
$secret = New-PodeCsrfSecret
# verify the token on the request, if invalid, throw a 403
$token = Get-PodeCsrfToken
if (!(Test-PodeCsrfToken -Secret $secret -Token $token)){
Set-PodeResponseStatus -Code 403 -Description 'Invalid CSRF Token'
return $false
}
# token is valid, move along
return $true
}
(New-PodeMiddleware -ScriptBlock $script) | Add-PodeMiddleware -Name '__pode_mw_csrf__'
}
<#
.SYNOPSIS
Adds a custom body parser middleware.
.DESCRIPTION
Adds a custom body parser middleware script for a content-type, which will be used if a payload is sent with a Request.
.PARAMETER ContentType
The ContentType of the custom body parser.
.PARAMETER ScriptBlock
The ScriptBlock that will parse the body content, and return the result.
.EXAMPLE
Add-PodeBodyParser -ContentType 'application/json' -ScriptBlock { param($body) /* parsing logic */ }
#>
function Add-PodeBodyParser
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[ValidatePattern('^\w+\/[\w\.\+-]+$')]
[string]
$ContentType,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[scriptblock]
$ScriptBlock
)
# if a parser for the type already exists, fail
if ($PodeContext.Server.BodyParsers.ContainsKey($ContentType)) {
throw "There is already a body parser defined for the $($ContentType) content-type"
}
# check if the scriptblock has any using vars
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
$PodeContext.Server.BodyParsers[$ContentType] = @{
ScriptBlock = $ScriptBlock
UsingVariables = $usingVars
}
}
<#
.SYNOPSIS
Removes a custom body parser.
.DESCRIPTION
Removes a custom body parser middleware script for a content-type.
.PARAMETER ContentType
The ContentType of the custom body parser.
.EXAMPLE
Remove-PodeBodyParser -ContentType 'application/json'
#>
function Remove-PodeBodyParser
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[ValidatePattern('^\w+\/[\w\.\+-]+$')]
[string]
$ContentType
)
# if there's no parser for the type, return
if (!$PodeContext.Server.BodyParsers.ContainsKey($ContentType)) {
return
}
$PodeContext.Server.BodyParsers.Remove($ContentType) | Out-Null
}
<#
.SYNOPSIS
Enables the OpenAPI default route in Pode.
.DESCRIPTION
Enables the OpenAPI default route in Pode, as well as setting up details like Title and API Version.
.PARAMETER Path
An optional custom route path to access the OpenAPI definition. (Default: /openapi)
.PARAMETER Title
The Title of the API.
.PARAMETER Version
The Version of the API. (Default: 0.0.0)
.PARAMETER Description
A Description of the API.
.PARAMETER RouteFilter
An optional route filter for routes that should be included in the definition. (Default: /*)
.PARAMETER Middleware
Like normal Routes, an array of Middleware that will be applied to the route.
.PARAMETER RestrictRoutes
If supplied, only routes that are available on the Requests URI will be used to generate the OpenAPI definition.
.EXAMPLE
Enable-PodeOpenApi -Title 'My API' -Version '1.0.0' -RouteFilter '/api/*'
.EXAMPLE
Enable-PodeOpenApi -Title 'My API' -Version '1.0.0' -RouteFilter '/api/*' -RestrictRoutes
.EXAMPLE
Enable-PodeOpenApi -Path '/docs/openapi' -Title 'My API' -Version '1.0.0'
#>
function Enable-PodeOpenApi
{
[CmdletBinding()]
param(
[Parameter()]
[ValidateNotNullOrEmpty()]
[string]
$Path = '/openapi',
[Parameter(Mandatory=$true)]
[string]
$Title,
[Parameter()]
[ValidateNotNullOrEmpty()]
[string]
$Version = '0.0.0',
[Parameter()]
[string]
$Description,
[Parameter()]
[ValidateNotNullOrEmpty()]
[string]
$RouteFilter = '/*',
[Parameter()]
[object[]]
$Middleware,
[switch]
$RestrictRoutes
)
# initialise openapi info
$PodeContext.Server.OpenAPI.Title = $Title
$PodeContext.Server.OpenAPI.Path = $Path
$meta = @{
Version = $Version
Description = $Description
RouteFilter = $RouteFilter
RestrictRoutes = $RestrictRoutes
}
# add the OpenAPI route
Add-PodeRoute -Method Get -Path $Path -ArgumentList $meta -Middleware $Middleware -ScriptBlock {
param($meta)
$strict = $meta.RestrictRoutes
# generate the openapi definition
$def = Get-PodeOpenApiDefinitionInternal `
-Title $PodeContext.Server.OpenAPI.Title `
-Version $meta.Version `
-Description $meta.Description `
-RouteFilter $meta.RouteFilter `
-Protocol $WebEvent.Endpoint.Protocol `
-Address $WebEvent.Endpoint.Address `
-EndpointName $WebEvent.Endpoint.Name `
-RestrictRoutes:$strict
# write the openapi definition
Write-PodeJsonResponse -Value $def -Depth 20
}
}
<#
.SYNOPSIS
Gets the OpenAPI definition.
.DESCRIPTION
Gets the OpenAPI definition for custom use in routes, or other functions.
.PARAMETER Title
The Title of the API. (Default: the title supplied in Enable-PodeOpenApi)
.PARAMETER Version
The Version of the API. (Default: the version supplied in Enable-PodeOpenApi)
.PARAMETER Description
A Description of the API. (Default: the description supplied into Enable-PodeOpenApi)
.PARAMETER RouteFilter
An optional route filter for routes that should be included in the definition. (Default: /*)
.PARAMETER RestrictRoutes
If supplied, only routes that are available on the Requests URI will be used to generate the OpenAPI definition.
.EXAMPLE
$def = Get-PodeOpenApiDefinition -RouteFilter '/api/*'
#>
function Get-PodeOpenApiDefinition
{
[CmdletBinding()]
param(
[Parameter()]
[string]
$Title,
[Parameter()]
[string]
$Version,
[Parameter()]
[string]
$Description,
[Parameter()]
[ValidateNotNullOrEmpty()]
[string]
$RouteFilter = '/*',
[switch]
$RestrictRoutes
)
$Title = Protect-PodeValue -Value $Title -Default $PodeContext.Server.OpenAPI.Title
if ([string]::IsNullOrWhiteSpace($Title)) {
throw "No Title supplied for OpenAPI definition"
}
$Version = Protect-PodeValue -Value $Version -Default $PodeContext.Server.OpenAPI.Version
if ([string]::IsNullOrWhiteSpace($Version)) {
throw "No Version supplied for OpenAPI definition"
}
$Description = Protect-PodeValue -Value $Description -Default $PodeContext.Server.OpenAPI.Description
# generate the openapi definition
return (Get-PodeOpenApiDefinitionInternal `
-Title $Title `
-Version $Version `
-Description $Description `
-RouteFilter $RouteFilter `
-Protocol $WebEvent.Endpoint.Protocol `
-Address $WebEvent.Endpoint.Address `
-EndpointName $WebEvent.Endpoint.Name `
-RestrictRoutes:$RestrictRoutes)
}
<#
.SYNOPSIS
Adds a response definition to the supplied route.
.DESCRIPTION
Adds a response definition to the supplied route.
.PARAMETER Route
The route to add the response definition, usually from -PassThru on Add-PodeRoute.
.PARAMETER StatusCode
The HTTP StatusCode for the response.
.PARAMETER ContentSchemas
The content-types and schema the response returns (the schema is created using the Property functions).
.PARAMETER HeaderSchemas
The header name and schema the response returns (the schema is created using the Property functions).
.PARAMETER Description
A Description of the response. (Default: the HTTP StatusCode description)
.PARAMETER Reference
A Reference Name of an existing component response to use.
.PARAMETER Default
If supplied, the response will be used as a default response - this overrides the StatusCode supplied.
.PARAMETER PassThru
If supplied, the route passed in will be returned for further chaining.
.EXAMPLE
Add-PodeRoute -PassThru | Add-PodeOAResponse -StatusCode 200 -ContentSchemas @{ 'application/json' = (New-PodeOAIntProperty -Name 'userId' -Object) }
.EXAMPLE
Add-PodeRoute -PassThru | Add-PodeOAResponse -StatusCode 200 -ContentSchemas @{ 'application/json' = 'UserIdSchema' }
.EXAMPLE
Add-PodeRoute -PassThru | Add-PodeOAResponse -StatusCode 200 -Reference 'OKResponse'
#>
function Add-PodeOAResponse
{
[CmdletBinding(DefaultParameterSetName='Schema')]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[ValidateNotNullOrEmpty()]
[hashtable[]]
$Route,
[Parameter(Mandatory=$true)]
[int]
$StatusCode,
[Parameter(ParameterSetName='Schema')]
[hashtable]
$ContentSchemas,
[Parameter(ParameterSetName='Schema')]
[hashtable]
$HeaderSchemas,
[Parameter(ParameterSetName='Schema')]
[string]
$Description = $null,
[Parameter(Mandatory=$true, ParameterSetName='Reference')]
[string]
$Reference,
[switch]
$Default,
[switch]
$PassThru
)
# set a general description for the status code
if (!$Default -and [string]::IsNullOrWhiteSpace($Description)) {
$Description = Get-PodeStatusDescription -StatusCode $StatusCode
}
# override status code with default
$code = "$($StatusCode)"
if ($Default) {
$code = 'default'
}
# schemas or component reference?
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'schema' {
# build any content-type schemas
$content = $null
if ($null -ne $ContentSchemas) {
$content = ($ContentSchemas | ConvertTo-PodeOAContentTypeSchema)
}
# build any header schemas
$headers = $null
if ($null -ne $HeaderSchemas) {
$headers = ($HeaderSchemas | ConvertTo-PodeOAHeaderSchema)
}
}
'reference' {
if (!(Test-PodeOAComponentResponse -Name $Reference)) {
throw "The OpenApi component response doesn't exist: $($Reference)"
}
}
}
# add the respones to the routes
foreach ($r in @($Route)) {
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'schema' {
$r.OpenApi.Responses[$code] = @{
description = $Description
content = $content
headers = $headers
}
}
'reference' {
$r.OpenApi.Responses[$code] = @{
'$ref' = "#/components/responses/$($Reference)"
}
}
}
}
if ($PassThru) {
return $Route
}
}
<#
.SYNOPSIS
Remove a response definition from the supplied route.
.DESCRIPTION
Remove a response definition from the supplied route.
.PARAMETER Route
The route to remove the response definition, usually from -PassThru on Add-PodeRoute.
.PARAMETER StatusCode
The HTTP StatusCode for the response to remove.
.PARAMETER Default
If supplied, the response will be used as a default response - this overrides the StatusCode supplied.
.PARAMETER PassThru
If supplied, the route passed in will be returned for further chaining.
.EXAMPLE
Add-PodeRoute -PassThru | Remove-PodeOAResponse -StatusCode 200
.EXAMPLE
Add-PodeRoute -PassThru | Remove-PodeOAResponse -StatusCode 201 -Default
#>
function Remove-PodeOAResponse
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[ValidateNotNullOrEmpty()]
[hashtable[]]
$Route,
[Parameter(Mandatory=$true)]
[int]
$StatusCode,
[switch]
$Default,
[switch]
$PassThru
)
# override status code with default
$code = "$($StatusCode)"
if ($Default) {
$code = 'default'
}
# remove the respones from the routes
foreach ($r in @($Route)) {
if ($r.OpenApi.Responses.ContainsKey($code)) {
$r.OpenApi.Responses.Remove($code) | Out-Null
}
}
if ($PassThru) {
return $Route
}
}
<#
.SYNOPSIS
Adds a reusable component for responses.
.DESCRIPTION
Adds a reusable component for responses.
.PARAMETER Name
The reference Name of the response.
.PARAMETER ContentSchemas
The content-types and schema the response returns (the schema is created using the Property functions).
.PARAMETER HeaderSchemas
The header name and schema the response returns (the schema is created using the Property functions).
.PARAMETER Description
The Description of the response.
.EXAMPLE
Add-PodeOAComponentResponse -Name 'OKResponse' -ContentSchemas @{ 'application/json' = (New-PodeOAIntProperty -Name 'userId' -Object) }
.EXAMPLE
Add-PodeOAComponentResponse -Name 'ErrorResponse' -ContentSchemas @{ 'application/json' = 'ErrorSchema' }
#>
function Add-PodeOAComponentResponse
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter()]
[hashtable]
$ContentSchemas,
[Parameter()]
[hashtable]
$HeaderSchemas,
[Parameter(Mandatory=$true)]
[string]
$Description
)
$content = $null
if ($null -ne $ContentSchemas) {
$content = ($ContentSchemas | ConvertTo-PodeOAContentTypeSchema)
}
$headers = $null
if ($null -ne $HeaderSchemas) {
$headers = ($HeaderSchemas | ConvertTo-PodeOAHeaderSchema)
}
$PodeContext.Server.OpenAPI.components.responses[$Name] = @{
description = $Description
content = $content
headers = $headers
}
}
<#
.SYNOPSIS
Sets the definition of a request for a route.
.DESCRIPTION
Sets the definition of a request for a route.
.PARAMETER Route
The route to set a request definition, usually from -PassThru on Add-PodeRoute.
.PARAMETER Parameters
The Parameter definitions the request uses (from ConvertTo-PodeOAParameter).
.PARAMETER RequestBody
The Request Body definition the request uses (from New-PodeOARequestBody).
.PARAMETER PassThru
If supplied, the route passed in will be returned for further chaining.
.EXAMPLE
Add-PodeRoute -PassThru | Set-PodeOARequest -RequestBody (New-PodeOARequestBody -Reference 'UserIdBody')
#>
function Set-PodeOARequest
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[ValidateNotNullOrEmpty()]
[hashtable[]]
$Route,
[Parameter()]
[hashtable[]]
$Parameters,
[Parameter()]
[hashtable]
$RequestBody,
[switch]
$PassThru
)
foreach ($r in @($Route)) {
if (($null -ne $Parameters) -and ($Parameters.Length -gt 0)) {
$r.OpenApi.Parameters = @($Parameters)
}
if ($null -ne $RequestBody) {
$r.OpenApi.RequestBody = $RequestBody
}
}
if ($PassThru) {
return $Route
}
}
<#
.SYNOPSIS
Creates a Request Body definition for routes.
.DESCRIPTION
Creates a Request Body definition for routes from the supplied content-types and schemas.
.PARAMETER Reference
A reference name from an existing component request body.
.PARAMETER ContentSchemas
The content-types and schema the request body accepts (the schema is created using the Property functions).
.PARAMETER Description
A Description of the request body.
.PARAMETER Required
If supplied, the request body will be flagged as required.
.EXAMPLE
New-PodeOARequestBody -ContentSchemas @{ 'application/json' = (New-PodeOAIntProperty -Name 'userId' -Object) }
.EXAMPLE
New-PodeOARequestBody -ContentSchemas @{ 'application/json' = 'UserIdSchema' }
.EXAMPLE
New-PodeOARequestBody -Reference 'UserIdBody'
#>
function New-PodeOARequestBody
{
[CmdletBinding(DefaultParameterSetName='Schema')]
param(
[Parameter(Mandatory=$true, ParameterSetName='Reference')]
[string]
$Reference,
[Parameter(Mandatory=$true, ParameterSetName='Schema')]
[hashtable]
$ContentSchemas,
[Parameter(ParameterSetName='Schema')]
[string]
$Description = $null,
[Parameter(ParameterSetName='Schema')]
[switch]
$Required
)
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'schema' {
return @{
required = $Required.IsPresent
description = $Description
content = ($ContentSchemas | ConvertTo-PodeOAContentTypeSchema)
}
}
'reference' {
if (!(Test-PodeOAComponentRequestBody -Name $Reference)) {
throw "The OpenApi component request body doesn't exist: $($Reference)"
}
return @{
'$ref' = "#/components/requestBodies/$($Reference)"
}
}
}
}
<#
.SYNOPSIS
Adds a reusable component for a request body.
.DESCRIPTION
Adds a reusable component for a request body.
.PARAMETER Name
The reference Name of the schema.
.PARAMETER Schema
The Schema definition (the schema is created using the Property functions).
.EXAMPLE
Add-PodeOAComponentSchema -Name 'UserIdSchema' -Schema (New-PodeOAIntProperty -Name 'userId' -Object)
#>
function Add-PodeOAComponentSchema
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$Schema
)
$PodeContext.Server.OpenAPI.components.schemas[$Name] = ($Schema | ConvertTo-PodeOASchemaProperty)
}
<#
.SYNOPSIS
Adds a reusable component for a request body.
.DESCRIPTION
Adds a reusable component for a request body.
.PARAMETER Name
The reference Name of the request body.
.PARAMETER ContentSchemas
The content-types and schema the request body accepts (the schema is created using the Property functions).
.PARAMETER Description
A Description of the request body.
.PARAMETER Required
If supplied, the request body will be flagged as required.
.EXAMPLE
Add-PodeOAComponentRequestBody -Name 'UserIdBody' -ContentSchemas @{ 'application/json' = (New-PodeOAIntProperty -Name 'userId' -Object) }
.EXAMPLE
Add-PodeOAComponentRequestBody -Name 'UserIdBody' -ContentSchemas @{ 'application/json' = 'UserIdSchema' }
#>
function Add-PodeOAComponentRequestBody
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$ContentSchemas,
[Parameter()]
[string]
$Description = $null,
[Parameter()]
[switch]
$Required
)
$PodeContext.Server.OpenAPI.components.requestBodies[$Name] = @{
required = $Required.IsPresent
description = $Description
content = ($ContentSchemas | ConvertTo-PodeOAContentTypeSchema)
}
}
<#
.SYNOPSIS
Adds a reusable component for a request parameter.
.DESCRIPTION
Adds a reusable component for a request parameter.
.PARAMETER Name
The reference Name of the parameter.
.PARAMETER Parameter
The Parameter to use for the component (from ConvertTo-PodeOAParameter)
.EXAMPLE
New-PodeOAIntProperty -Name 'userId' | ConvertTo-PodeOAParameter -In Query | Add-PodeOAComponentParameter -Name 'UserIdParam'
#>
function Add-PodeOAComponentParameter
{
[CmdletBinding()]
param(
[Parameter()]
[string]
$Name,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[hashtable]
$Parameter
)
if ([string]::IsNullOrWhiteSpace($Name)) {
$Name = $Parameter.name
}
$PodeContext.Server.OpenAPI.components.parameters[$Name] = $Parameter
}
<#
.SYNOPSIS
Creates a new OpenAPI integer property.
.DESCRIPTION
Creates a new OpenAPI integer property, for Schemas or Parameters.
.PARAMETER Name
The Name of the property.
.PARAMETER Format
The inbuilt OpenAPI Format of the integer. (Default: Any)
.PARAMETER Default
The default value of the property. (Default: 0)
.PARAMETER Minimum
The minimum value of the integer. (Default: Int.Min)
.PARAMETER Maximum
The maximum value of the integer. (Default: Int.Max)
.PARAMETER MultiplesOf
The integer must be in multiples of the supplied value.
.PARAMETER Description
A Description of the property.
.PARAMETER Enum
An optional array of values that this property can only be set to.
.PARAMETER Required
If supplied, the object will be treated as Required where supported.
.PARAMETER Deprecated
If supplied, the object will be treated as Deprecated where supported.
.PARAMETER Array
If supplied, the integer will be treated as an array of integers.
.PARAMETER Object
If supplied, the integer will be automatically wrapped in an object.
.EXAMPLE
New-PodeOANumberProperty -Name 'age' -Required
#>
function New-PodeOAIntProperty
{
[CmdletBinding()]
param(
[Parameter()]
[string]
$Name,
[Parameter()]
[ValidateSet('', 'Int32', 'Int64')]
[string]
$Format,
[Parameter()]
[int]
$Default = 0,
[Parameter()]
[int]
$Minimum = [int]::MinValue,
[Parameter()]
[int]
$Maximum = [int]::MaxValue,
[Parameter()]
[int]
$MultiplesOf = 0,
[Parameter()]
[string]
$Description,
[Parameter()]
[int[]]
$Enum,
[switch]
$Required,
[switch]
$Deprecated,
[switch]
$Array,
[switch]
$Object
)
$param = @{
name = $Name
type = 'integer'
array = $Array.IsPresent
object = $Object.IsPresent
required = $Required.IsPresent
deprecated = $Deprecated.IsPresent
description = $Description
format = $Format.ToLowerInvariant()
enum = $Enum
default = $Default
}
if ($Minimum -ne [int]::MinValue) {
$param['minimum'] = $Minimum
}
if ($Maximum -ne [int]::MaxValue) {
$param['maximum'] = $Maximum
}
if ($MultiplesOf -ne 0) {
$param['multipleOf'] = $MultiplesOf
}
return $param
}
<#
.SYNOPSIS
Creates a new OpenAPI number property.
.DESCRIPTION
Creates a new OpenAPI number property, for Schemas or Parameters.
.PARAMETER Name
The Name of the property.
.PARAMETER Format
The inbuilt OpenAPI Format of the number. (Default: Any)
.PARAMETER Default
The default value of the property. (Default: 0)
.PARAMETER Minimum
The minimum value of the number. (Default: Double.Min)
.PARAMETER Maximum
The maximum value of the number. (Default: Double.Max)
.PARAMETER MultiplesOf
The number must be in multiples of the supplied value.
.PARAMETER Description
A Description of the property.
.PARAMETER Enum
An optional array of values that this property can only be set to.
.PARAMETER Required
If supplied, the object will be treated as Required where supported.
.PARAMETER Deprecated
If supplied, the object will be treated as Deprecated where supported.
.PARAMETER Array
If supplied, the number will be treated as an array of numbers.
.PARAMETER Object
If supplied, the number will be automatically wrapped in an object.
.EXAMPLE
New-PodeOANumberProperty -Name 'gravity' -Default 9.8
#>
function New-PodeOANumberProperty
{
[CmdletBinding()]
param(
[Parameter()]
[string]
$Name,
[Parameter()]
[ValidateSet('', 'Double', 'Float')]
[string]
$Format,
[Parameter()]
[double]
$Default = 0,
[Parameter()]
[double]
$Minimum = [double]::MinValue,
[Parameter()]
[double]
$Maximum = [double]::MaxValue,
[Parameter()]
[double]
$MultiplesOf = 0,
[Parameter()]
[string]
$Description,
[Parameter()]
[double[]]
$Enum,
[switch]
$Required,
[switch]
$Deprecated,
[switch]
$Array,
[switch]
$Object
)
$param = @{
name = $Name
type = 'number'
array = $Array.IsPresent
object = $Object.IsPresent
required = $Required.IsPresent
deprecated = $Deprecated.IsPresent
description = $Description
format = $Format.ToLowerInvariant()
enum = $Enum
default = $Default
}
if ($Minimum -ne [double]::MinValue) {
$param['minimum'] = $Minimum
}
if ($Maximum -ne [double]::MaxValue) {
$param['maximum'] = $Maximum
}
if ($MultiplesOf -ne 0) {
$param['multipleOf'] = $MultiplesOf
}
return $param
}
<#
.SYNOPSIS
Creates a new OpenAPI string property.
.DESCRIPTION
Creates a new OpenAPI string property, for Schemas or Parameters.
.PARAMETER Name
The Name of the property.
.PARAMETER Format
The inbuilt OpenAPI Format of the string. (Default: Any)
.PARAMETER CustomFormat
The name of a custom OpenAPI Format of the string. (Default: None)
.PARAMETER Default
The default value of the property. (Default: $null)
.PARAMETER MinLength
The minimum length of the string. (Default: Int.Min)
.PARAMETER MaxLength
The maximum length of the string. (Default: Int.Max)
.PARAMETER Pattern
A Regex pattern that the string must match.
.PARAMETER Description
A Description of the property.
.PARAMETER Enum
An optional array of values that this property can only be set to.
.PARAMETER Required
If supplied, the object will be treated as Required where supported.
.PARAMETER Deprecated
If supplied, the object will be treated as Deprecated where supported.
.PARAMETER Array
If supplied, the string will be treated as an array of strings.
.PARAMETER Object
If supplied, the string will be automatically wrapped in an object.
.EXAMPLE
New-PodeOAStringProperty -Name 'userType' -Default 'admin'
.EXAMPLE
New-PodeOAStringProperty -Name 'password' -Format Password
#>
function New-PodeOAStringProperty
{
[CmdletBinding(DefaultParameterSetName='Inbuilt')]
param(
[Parameter()]
[string]
$Name,
[Parameter(ParameterSetName='Inbuilt')]
[ValidateSet('', 'Binary', 'Byte', 'Date', 'Date-Time', 'Password')]
[string]
$Format,
[Parameter(ParameterSetName='Custom')]
[string]
$CustomFormat,
[Parameter()]
[string]
$Default = $null,
[Parameter()]
[int]
$MinLength = [int]::MinValue,
[Parameter()]
[int]
$MaxLength = [int]::MaxValue,
[Parameter()]
[string]
$Pattern = $null,
[Parameter()]
[string]
$Description,
[Parameter()]
[string[]]
$Enum,
[switch]
$Required,
[switch]
$Deprecated,
[switch]
$Array,
[switch]
$Object
)
$_format = $Format
if (![string]::IsNullOrWhiteSpace($CustomFormat)) {
$_format = $CustomFormat
}
$param = @{
name = $Name
type = 'string'
array = $Array.IsPresent
object = $Object.IsPresent
required = $Required.IsPresent
deprecated = $Deprecated.IsPresent
description = $Description
format = $_format.ToLowerInvariant()
enum = $Enum
pattern = $Pattern
default = $Default
}
if ($MinLength -ne [int]::MinValue) {
$param['minLength'] = $MinLength
}
if ($MaxLength -ne [int]::MaxValue) {
$param['maxLength'] = $MaxLength
}
return $param
}
<#
.SYNOPSIS
Creates a new OpenAPI boolean property.
.DESCRIPTION
Creates a new OpenAPI boolean property, for Schemas or Parameters.
.PARAMETER Name
The Name of the property.
.PARAMETER Default
The default value of the property. (Default: $false)
.PARAMETER Description
A Description of the property.
.PARAMETER Enum
An optional array of values that this property can only be set to.
.PARAMETER Required
If supplied, the object will be treated as Required where supported.
.PARAMETER Deprecated
If supplied, the object will be treated as Deprecated where supported.
.PARAMETER Array
If supplied, the boolean will be treated as an array of booleans.
.PARAMETER Object
If supplied, the boolean will be automatically wrapped in an object.
.EXAMPLE
New-PodeOABoolProperty -Name 'enabled' -Required
#>
function New-PodeOABoolProperty
{
[CmdletBinding()]
param(
[Parameter()]
[string]
$Name,
[Parameter()]
[bool]
$Default = $false,
[Parameter()]
[string]
$Description,
[Parameter()]
[bool[]]
$Enum,
[switch]
$Required,
[switch]
$Deprecated,
[switch]
$Array,
[switch]
$Object
)
$param = @{
name = $Name
type = 'boolean'
array = $Array.IsPresent
object = $Object.IsPresent
required = $Required.IsPresent
deprecated = $Deprecated.IsPresent
description = $Description
enum = $Enum
default = $Default
}
return $param
}
<#
.SYNOPSIS
Creates a new OpenAPI object property from other properties.
.DESCRIPTION
Creates a new OpenAPI object property from other properties, for Schemas or Parameters.
.PARAMETER Name
The Name of the property.
.PARAMETER Properties
An array of other int/string/etc properties wrap up as an object.
.PARAMETER Description
A Description of the property.
.PARAMETER Required
If supplied, the object will be treated as Required where supported.
.PARAMETER Deprecated
If supplied, the object will be treated as Deprecated where supported.
.PARAMETER Array
If supplied, the object will be treated as an array of objects.
.EXAMPLE
New-PodeOAObjectProperty -Name 'user' -Properties @('<ARRAY_OF_PROPERTIES>')
#>
function New-PodeOAObjectProperty
{
[CmdletBinding()]
param(
[Parameter()]
[string]
$Name,
[Parameter(Mandatory=$true)]
[hashtable[]]
$Properties,
[Parameter()]
[string]
$Description,
[switch]
$Required,
[switch]
$Deprecated,
[switch]
$Array
)
$param = @{
name = $Name
type = 'object'
array = $Array.IsPresent
required = $Required.IsPresent
deprecated = $Deprecated.IsPresent
description = $Description
properties = $Properties
default = $Default
}
return $param
}
<#
.SYNOPSIS
Converts an OpenAPI property into a Request Parameter.
.DESCRIPTION
Converts an OpenAPI property (such as from New-PodeOAIntProperty) into a Request Parameter.
.PARAMETER In
Where in the Request can the parameter be found?
.PARAMETER Property
The Property that need converting (such as from New-PodeOAIntProperty).
.PARAMETER Reference
The name of an existing component parameter to be reused.
.EXAMPLE
New-PodeOAIntProperty -Name 'userId' | ConvertTo-PodeOAParameter -In Query
.EXAMPLE
ConvertTo-PodeOAParameter -Reference 'UserIdParam'
#>
function ConvertTo-PodeOAParameter
{
[CmdletBinding(DefaultParameterSetName='Reference')]
param(
[Parameter(Mandatory=$true, ParameterSetName='Schema')]
[ValidateSet('Cookie', 'Header', 'Path', 'Query')]
[string]
$In,
[Parameter(Mandatory=$true, ValueFromPipeline=$true, ParameterSetName='Schema')]
[ValidateNotNull()]
[hashtable]
$Property,
[Parameter(Mandatory=$true, ParameterSetName='Reference')]
[string]
$Reference
)
# return a reference
if ($PSCmdlet.ParameterSetName -ieq 'reference') {
if (!(Test-PodeOAComponentParameter -Name $Reference)) {
throw "The OpenApi component request parameter doesn't exist: $($Reference)"
}
return @{
'$ref' = "#/components/parameters/$($Reference)"
}
}
# non-object/array only
if (@('array', 'object') -icontains $Property.type) {
throw "OpenApi request parameter cannot be an array of object"
}
# build the base parameter
$prop = @{
in = $In.ToLowerInvariant()
name = $Property.name
required = $Property.required
description = $Property.description
deprecated = $Property.deprecated
schema = @{
type = $Property.type
format = $Property.format
enum = $Property.enum
}
}
# remove default for required parameter
if (!$Property.required) {
$prop.schema['default'] = $Property.default
}
return $prop
}
<#
.SYNOPSIS
Sets metadate for the supplied route.
.DESCRIPTION
Sets metadate for the supplied route, such as Summary and Tags.
.PARAMETER Route
The route to update info, usually from -PassThru on Add-PodeRoute.
.PARAMETER Summary
A quick Summary of the route.
.PARAMETER Description
A longer Description of the route.
.PARAMETER OperationId
Sets the OperationId of the route.
.PARAMETER Tags
An array of Tags for the route, mostly for grouping.
.PARAMETER Deprecated
If supplied, the route will be flagged as deprecated.
.PARAMETER PassThru
If supplied, the route passed in will be returned for further chaining.
.EXAMPLE
Add-PodeRoute -PassThru | Set-PodeOARouteInfo -Summary 'A quick summary' -Tags 'Admin'
#>
function Set-PodeOARouteInfo
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[ValidateNotNullOrEmpty()]
[hashtable[]]
$Route,
[Parameter()]
[string]
$Summary,
[Parameter()]
[string]
$Description,
[Parameter()]
[string]
$OperationId,
[Parameter()]
[string[]]
$Tags,
[switch]
$Deprecated,
[switch]
$PassThru
)
foreach ($r in @($Route)) {
$r.OpenApi.Summary = $Summary
$r.OpenApi.Description = $Description
$r.OpenApi.OperationId = $OperationId
$r.OpenApi.Tags = $Tags
$r.OpenApi.Deprecated = $Deprecated.IsPresent
}
if ($PassThru) {
return $Route
}
}
<#
.SYNOPSIS
Adds a route that enables a viewer to display OpenAPI docs, such as Swagger or ReDoc.
.DESCRIPTION
Adds a route that enables a viewer to display OpenAPI docs, such as Swagger or ReDoc.
.PARAMETER Type
The Type of OpenAPI viewer to use.
.PARAMETER Path
The route Path where the docs can be accessed. (Default: "/$Type")
.PARAMETER OpenApiUrl
The URL where the OpenAPI definition can be retrieved. (Default is the OpenAPI path from Enable-PodeOpenApi)
.PARAMETER Middleware
Like normal Routes, an array of Middleware that will be applied.
.PARAMETER Title
The title of the web page.
.PARAMETER DarkMode
If supplied, the page will be rendered using a dark theme (this is not supported for all viewers).
.EXAMPLE
Enable-PodeOpenApiViewer -Type Swagger -DarkMode
.EXAMPLE
Enable-PodeOpenApiViewer -Type ReDoc -Title 'Some Title' -OpenApi 'http://some-url/openapi'
#>
function Enable-PodeOpenApiViewer
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[ValidateSet('Swagger', 'ReDoc')]
[string]
$Type,
[Parameter()]
[string]
$Path,
[Parameter()]
[string]
$OpenApiUrl,
[Parameter()]
[object[]]
$Middleware,
[Parameter()]
[string]
$Title,
[switch]
$DarkMode
)
# error if there's no OpenAPI URL
$OpenApiUrl = Protect-PodeValue -Value $OpenApiUrl -Default $PodeContext.Server.OpenAPI.Path
if ([string]::IsNullOrWhiteSpace($OpenApiUrl)) {
throw "No OpenAPI URL supplied for $($Type)"
}
# fail if no title
$Title = Protect-PodeValue -Value $Title -Default $PodeContext.Server.OpenAPI.Title
$Title = Protect-PodeValue -Value $Title -Default $Type
if ([string]::IsNullOrWhiteSpace($Title)) {
throw "No title supplied for $($Type) page"
}
# set a default path
$Path = Protect-PodeValue -Value $Path -Default "/$($Type.ToLowerInvariant())"
if ([string]::IsNullOrWhiteSpace($Title)) {
throw "No route path supplied for $($Type) page"
}
# setup meta info
$meta = @{
Type = $Type.ToLowerInvariant()
Title = $Title
OpenApi = $OpenApiUrl
DarkMode = $DarkMode
}
# add the viewer route
Add-PodeRoute -Method Get -Path $Path -Middleware $Middleware -ArgumentList $meta -ScriptBlock {
param($meta)
$podeRoot = Get-PodeModuleMiscPath
Write-PodeFileResponse -Path (Join-Path $podeRoot "default-$($meta.Type).html.pode") -Data @{
Title = $meta.Title
OpenApi = $meta.OpenApi
DarkMode = $meta.DarkMode
}
}
}
<#
.SYNOPSIS
Attaches a file onto the Response for downloading.
.DESCRIPTION
Attaches a file from the "/public", and static Routes, onto the Response for downloading.
If the supplied path is not in the Static Routes but is a literal/relative path, then this file is used instead.
.PARAMETER Path
The Path to a static file relative to the "/public" directory, or a static Route.
If the supplied Path doesn't match any custom static Route, then Pode will look in the "/public" directory.
Failing this, if the file path exists as a literal/relative file, then this file is used as a fall back.
.PARAMETER ContentType
Manually specify the content type of the response rather than infering it from the attachment's file extension.
The supplied value must match the valid ContentType format, e.g. application/json
.PARAMETER EndpointName
Optional EndpointName that the static route was creating under.
.EXAMPLE
Set-PodeResponseAttachment -Path 'downloads/installer.exe'
.EXAMPLE
Set-PodeResponseAttachment -Path './image.png'
.EXAMPLE
Set-PodeResponseAttachment -Path 'c:/content/accounts.xlsx'
.EXAMPLE
Set-PodeResponseAttachment -Path './data.txt' -ContentType 'application/json'
.EXAMPLE
Set-PodeResponseAttachment -Path '/assets/data.txt' -EndpointName 'Example'
#>
function Set-PodeResponseAttachment
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Path,
[ValidatePattern('^\w+\/[\w\.\+-]+$')]
[string]
$ContentType,
[Parameter()]
[string]
$EndpointName
)
# only attach files from public/static-route directories when path is relative
$_path = (Find-PodeStaticRoute -Path $Path -CheckPublic -EndpointName $EndpointName).Content.Source
# if there's no path, check the original path (in case it's literal/relative)
if (!(Test-PodePath $_path -NoStatus)) {
$Path = Get-PodeRelativePath -Path $Path -JoinRoot
if (Test-PodePath $Path -NoStatus) {
$_path = $Path
}
}
# test the file path, and set status accordingly
if (!(Test-PodePath $_path)) {
return
}
$filename = Get-PodeFileName -Path $_path
$ext = Get-PodeFileExtension -Path $_path -TrimPeriod
try {
# setup the content type and disposition
if (!$ContentType) {
$WebEvent.Response.ContentType = (Get-PodeContentType -Extension $ext)
}
else {
$WebEvent.Response.ContentType = $ContentType
}
Set-PodeHeader -Name 'Content-Disposition' -Value "attachment; filename=$($filename)"
# if serverless, get the content raw and return
if (!$WebEvent.Streamed) {
if (Test-PodeIsPSCore) {
$content = (Get-Content -Path $_path -Raw -AsByteStream)
}
else {
$content = (Get-Content -Path $_path -Raw -Encoding byte)
}
$WebEvent.Response.Body = $content
}
# else if normal, stream the content back
else {
# setup the response details and headers
$WebEvent.Response.SendChunked = $false
# set file as an attachment on the response
$buffer = [byte[]]::new(64 * 1024)
$read = 0
# open up the file as a stream
$fs = (Get-Item $_path).OpenRead()
$WebEvent.Response.ContentLength64 = $fs.Length
while (($read = $fs.Read($buffer, 0, $buffer.Length)) -gt 0) {
$WebEvent.Response.OutputStream.Write($buffer, 0, $read)
}
}
}
finally {
Close-PodeDisposable -Disposable $fs
}
}
<#
.SYNOPSIS
Writes a String or a Byte[] to the Response.
.DESCRIPTION
Writes a String or a Byte[] to the Response, as some specified content type. This value can also be cached.
.PARAMETER Value
A String value to write.
.PARAMETER Bytes
An array of Bytes to write.
.PARAMETER ContentType
The content type of the data being written.
.PARAMETER MaxAge
The maximum age to cache the value on the browser, in seconds.
.PARAMETER StatusCode
The status code to set against the response.
.PARAMETER Cache
Should the value be cached by browsers, or not?
.EXAMPLE
Write-PodeTextResponse -Value 'Leeeeeerrrooooy Jeeeenkiiins!'
.EXAMPLE
Write-PodeTextResponse -Value '{"name": "Rick"}' -ContentType 'application/json'
.EXAMPLE
Write-PodeTextResponse -Bytes (Get-Content -Path ./some/image.png -Raw -AsByteStream) -Cache -MaxAge 1800
.EXAMPLE
Write-PodeTextResponse -Value 'Untitled Text Response' -StatusCode 418
#>
function Write-PodeTextResponse
{
[CmdletBinding(DefaultParameterSetName='String')]
param (
[Parameter(ParameterSetName='String', ValueFromPipeline=$true)]
[string]
$Value,
[Parameter(ParameterSetName='Bytes')]
[byte[]]
$Bytes,
[Parameter()]
[string]
$ContentType = 'text/plain',
[Parameter()]
[int]
$MaxAge = 3600,
[Parameter()]
[int]
$StatusCode = 200,
[switch]
$Cache
)
$isStringValue = ($PSCmdlet.ParameterSetName -ieq 'string')
$isByteValue = ($PSCmdlet.ParameterSetName -ieq 'bytes')
# set the status code of the response, but only if it's not 200 (to prevent overriding)
if ($StatusCode -ne 200) {
Set-PodeResponseStatus -Code $StatusCode -NoErrorPage
}
# if there's nothing to write, return
if ($isStringValue -and [string]::IsNullOrWhiteSpace($Value)) {
return
}
if ($isByteValue -and (($null -eq $Bytes) -or ($Bytes.Length -eq 0))) {
return
}
# if the response stream isn't writable, return
$res = $WebEvent.Response
if (($null -eq $res) -or ($WebEvent.Streamed -and (($null -eq $res.OutputStream) -or !$res.OutputStream.CanWrite))) {
return
}
# set a cache value
if ($Cache) {
Set-PodeHeader -Name 'Cache-Control' -Value "max-age=$($MaxAge), must-revalidate"
Set-PodeHeader -Name 'Expires' -Value ([datetime]::UtcNow.AddSeconds($MaxAge).ToString("r", [CultureInfo]::InvariantCulture))
}
# specify the content-type if supplied (adding utf-8 if missing)
if (![string]::IsNullOrWhiteSpace($ContentType)) {
$charset = 'charset=utf-8'
if ($ContentType -inotcontains $charset) {
$ContentType = "$($ContentType); $($charset)"
}
$res.ContentType = $ContentType
}
# if we're serverless, set the string as the body
if (!$WebEvent.Streamed) {
if ($isStringValue) {
$res.Body = $Value
}
else {
$res.Body = $Bytes
}
}
else {
# convert string to bytes
if ($isStringValue) {
$Bytes = ConvertFrom-PodeValueToBytes -Value $Value
}
# check if we need to compress the response
if ($PodeContext.Server.Web.Compression.Enabled -and ![string]::IsNullOrWhiteSpace($WebEvent.AcceptEncoding)) {
try {
$ms = New-Object -TypeName System.IO.MemoryStream
$stream = New-Object "System.IO.Compression.$($WebEvent.AcceptEncoding)Stream"($ms, [System.IO.Compression.CompressionMode]::Compress, $true)
$stream.Write($Bytes, 0, $Bytes.Length)
$stream.Close()
$ms.Position = 0
$Bytes = $ms.ToArray()
}
finally {
if ($null -ne $stream) {
$stream.Close()
}
if ($null -ne $ms) {
$ms.Close()
}
}
# set content encoding header
Set-PodeHeader -Name 'Content-Encoding' -Value $WebEvent.AcceptEncoding
}
# write the content to the response stream
$res.ContentLength64 = $Bytes.Length
try {
$ms = New-Object -TypeName System.IO.MemoryStream
$ms.Write($Bytes, 0, $Bytes.Length)
$ms.WriteTo($res.OutputStream)
}
catch {
if ((Test-PodeValidNetworkFailure $_.Exception)) {
return
}
$_ | Write-PodeErrorLog
throw
}
finally {
if ($null -ne $ms) {
$ms.Close()
}
}
}
}
<#
.SYNOPSIS
Renders the content of a static, or dynamic, file on the Response.
.DESCRIPTION
Renders the content of a static, or dynamic, file on the Response.
You can set browser's to cache the content, and also override the file's content type.
.PARAMETER Path
The path to a file.
.PARAMETER Data
A HashTable of dynamic data to supply to a dynamic file.
.PARAMETER ContentType
The content type of the file's contents - this overrides the file's extension.
.PARAMETER MaxAge
The maximum age to cache the file's content on the browser, in seconds.
.PARAMETER StatusCode
The status code to set against the response.
.PARAMETER Cache
Should the file's content be cached by browsers, or not?
.EXAMPLE
Write-PodeFileResponse -Path 'C:/Files/Stuff.txt'
.EXAMPLE
Write-PodeFileResponse -Path 'C:/Files/Stuff.txt' -Cache -MaxAge 1800
.EXAMPLE
Write-PodeFileResponse -Path 'C:/Files/Stuff.txt' -ContentType 'application/json'
.EXAMPLE
Write-PodeFileResponse -Path 'C:/Views/Index.pode' -Data @{ Counter = 2 }
.EXAMPLE
Write-PodeFileResponse -Path 'C:/Files/Stuff.txt' -StatusCode 201
#>
function Write-PodeFileResponse
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[ValidateNotNull()]
[string]
$Path,
[Parameter()]
$Data = @{},
[Parameter()]
[string]
$ContentType = $null,
[Parameter()]
[int]
$MaxAge = 3600,
[Parameter()]
[int]
$StatusCode = 200,
[switch]
$Cache
)
# resolve for relative path
$Path = Get-PodeRelativePath -Path $Path -JoinRoot
# test the file path, and set status accordingly
if (!(Test-PodePath $Path -FailOnDirectory)) {
return
}
# are we dealing with a dynamic file for the view engine? (ignore html)
$mainExt = Get-PodeFileExtension -Path $Path -TrimPeriod
# generate dynamic content
if (![string]::IsNullOrWhiteSpace($mainExt) -and (
($mainExt -ieq 'pode') -or
($mainExt -ieq $PodeContext.Server.ViewEngine.Extension -and $PodeContext.Server.ViewEngine.IsDynamic)
)) {
$content = Get-PodeFileContentUsingViewEngine -Path $Path -Data $Data
# get the sub-file extension, if empty, use original
$subExt = Get-PodeFileExtension -Path (Get-PodeFileName -Path $Path -WithoutExtension) -TrimPeriod
$subExt = (Protect-PodeValue -Value $subExt -Default $mainExt)
$ContentType = (Protect-PodeValue -Value $ContentType -Default (Get-PodeContentType -Extension $subExt))
Write-PodeTextResponse -Value $content -ContentType $ContentType -StatusCode $StatusCode
}
# this is a static file
else {
if (Test-PodeIsPSCore) {
$content = (Get-Content -Path $Path -Raw -AsByteStream)
}
else {
$content = (Get-Content -Path $Path -Raw -Encoding byte)
}
$ContentType = (Protect-PodeValue -Value $ContentType -Default (Get-PodeContentType -Extension $mainExt))
Write-PodeTextResponse -Bytes $content -ContentType $ContentType -MaxAge $MaxAge -StatusCode $StatusCode -Cache:$Cache
}
}
<#
.SYNOPSIS
Writes CSV data to the Response.
.DESCRIPTION
Writes CSV data to the Response, setting the content type accordingly.
.PARAMETER Value
A String, PSObject, or HashTable value.
.PARAMETER Path
The path to a CSV file.
.PARAMETER StatusCode
The status code to set against the response.
.EXAMPLE
Write-PodeCsvResponse -Value "Name`nRick"
.EXAMPLE
Write-PodeCsvResponse -Value @{ Name = 'Rick' }
.EXAMPLE
Write-PodeCsvResponse -Path 'E:/Files/Names.csv'
#>
function Write-PodeCsvResponse
{
[CmdletBinding(DefaultParameterSetName='Value')]
param (
[Parameter(Mandatory=$true, ParameterSetName='Value', ValueFromPipeline=$true)]
$Value,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$Path,
[Parameter()]
[int]
$StatusCode = 200
)
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'file' {
if (Test-PodePath $Path) {
$Value = Get-PodeFileContent -Path $Path
}
}
'value' {
if ($Value -isnot [string]) {
$Value = @(foreach ($v in $Value) {
New-Object psobject -Property $v
})
if (Test-PodeIsPSCore) {
$Value = ($Value | ConvertTo-Csv -Delimiter ',' -IncludeTypeInformation:$false)
}
else {
$Value = ($Value | ConvertTo-Csv -Delimiter ',' -NoTypeInformation)
}
$Value = ($Value -join ([environment]::NewLine))
}
}
}
if ([string]::IsNullOrWhiteSpace($Value)) {
$Value = [string]::Empty
}
Write-PodeTextResponse -Value $Value -ContentType 'text/csv' -StatusCode $StatusCode
}
<#
.SYNOPSIS
Writes HTML data to the Response.
.DESCRIPTION
Writes HTML data to the Response, setting the content type accordingly.
.PARAMETER Value
A String, PSObject, or HashTable value.
.PARAMETER Path
The path to a HTML file.
.PARAMETER StatusCode
The status code to set against the response.
.EXAMPLE
Write-PodeHtmlResponse -Value '<html><body>Hello!</body></html>'
.EXAMPLE
Write-PodeHtmlResponse -Value @{ Message = 'Hello, all!' }
.EXAMPLE
Write-PodeHtmlResponse -Path 'E:/Site/About.html'
#>
function Write-PodeHtmlResponse
{
[CmdletBinding(DefaultParameterSetName='Value')]
param (
[Parameter(Mandatory=$true, ParameterSetName='Value', ValueFromPipeline=$true)]
$Value,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$Path,
[Parameter()]
[int]
$StatusCode = 200
)
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'file' {
if (Test-PodePath $Path) {
$Value = Get-PodeFileContent -Path $Path
}
}
'value' {
if ($Value -isnot [string]) {
$Value = ($Value | ConvertTo-Html)
$Value = ($Value -join ([environment]::NewLine))
}
}
}
if ([string]::IsNullOrWhiteSpace($Value)) {
$Value = [string]::Empty
}
Write-PodeTextResponse -Value $Value -ContentType 'text/html' -StatusCode $StatusCode
}
<#
.SYNOPSIS
Writes Markdown data to the Response.
.DESCRIPTION
Writes Markdown data to the Response, with the option to render it as HTML.
.PARAMETER Value
A String, PSObject, or HashTable value.
.PARAMETER Path
The path to a Markdown file.
.PARAMETER StatusCode
The status code to set against the response.
.PARAMETER AsHtml
If supplied, the Markdown will be converted to HTML. (This is only supported in PS7+)
.EXAMPLE
Write-PodeMarkdownResponse -Value '# Hello, world!' -AsHtml
.EXAMPLE
Write-PodeMarkdownResponse -Path 'E:/Site/About.md'
#>
function Write-PodeMarkdownResponse
{
[CmdletBinding(DefaultParameterSetName='Value')]
param (
[Parameter(Mandatory=$true, ParameterSetName='Value', ValueFromPipeline=$true)]
$Value,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$Path,
[Parameter()]
[int]
$StatusCode = 200,
[switch]
$AsHtml
)
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'file' {
if (Test-PodePath $Path) {
$Value = Get-PodeFileContent -Path $Path
}
}
}
if ([string]::IsNullOrWhiteSpace($Value)) {
$Value = [string]::Empty
}
$mimeType = 'text/markdown'
if ($AsHtml) {
if ($PSVersionTable.PSVersion.Major -ge 7) {
$mimeType = 'text/html'
$Value = ($Value | ConvertFrom-Markdown).Html
}
}
Write-PodeTextResponse -Value $Value -ContentType $mimeType -StatusCode $StatusCode
}
<#
.SYNOPSIS
Writes JSON data to the Response.
.DESCRIPTION
Writes JSON data to the Response, setting the content type accordingly.
.PARAMETER Value
A String, PSObject, or HashTable value. For non-string values, they will be converted to JSON.
.PARAMETER Path
The path to a JSON file.
.PARAMETER Depth
The Depth to generate the JSON document - the larger this value the worse performance gets.
.PARAMETER StatusCode
The status code to set against the response.
.EXAMPLE
Write-PodeJsonResponse -Value '{"name": "Rick"}'
.EXAMPLE
Write-PodeJsonResponse -Value @{ Name = 'Rick' } -StatusCode 201
.EXAMPLE
Write-PodeJsonResponse -Path 'E:/Files/Names.json'
#>
function Write-PodeJsonResponse
{
[CmdletBinding(DefaultParameterSetName='Value')]
param (
[Parameter(Mandatory=$true, ParameterSetName='Value', ValueFromPipeline=$true)]
$Value,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$Path,
[Parameter()]
[int]
$Depth = 10,
[Parameter()]
[int]
$StatusCode = 200
)
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'file' {
if (Test-PodePath $Path) {
$Value = Get-PodeFileContent -Path $Path
}
}
'value' {
if ($Value -isnot [string]) {
if ($Depth -le 0) {
$Value = ($Value | ConvertTo-Json -Compress)
}
else {
$Value = ($Value | ConvertTo-Json -Depth $Depth -Compress)
}
}
}
}
if ([string]::IsNullOrWhiteSpace($Value)) {
$Value = '{}'
}
Write-PodeTextResponse -Value $Value -ContentType 'application/json' -StatusCode $StatusCode
}
<#
.SYNOPSIS
Writes XML data to the Response.
.DESCRIPTION
Writes XML data to the Response, setting the content type accordingly.
.PARAMETER Value
A String, PSObject, or HashTable value.
.PARAMETER Path
The path to an XML file.
.PARAMETER StatusCode
The status code to set against the response.
.EXAMPLE
Write-PodeXmlResponse -Value '<root><name>Rick</name></root>'
.EXAMPLE
Write-PodeXmlResponse -Value @{ Name = 'Rick' } -StatusCode 201
.EXAMPLE
Write-PodeXmlResponse -Path 'E:/Files/Names.xml'
#>
function Write-PodeXmlResponse
{
[CmdletBinding(DefaultParameterSetName='Value')]
param (
[Parameter(Mandatory=$true, ParameterSetName='Value', ValueFromPipeline=$true)]
$Value,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$Path,
[Parameter()]
[int]
$StatusCode = 200
)
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'file' {
if (Test-PodePath $Path) {
$Value = Get-PodeFileContent -Path $Path
}
}
'value' {
if ($Value -isnot [string]) {
$Value = @(foreach ($v in $Value) {
New-Object psobject -Property $v
})
$Value = ($Value | ConvertTo-Xml -Depth 10 -As String -NoTypeInformation)
}
}
}
if ([string]::IsNullOrWhiteSpace($Value)) {
$Value = [string]::Empty
}
Write-PodeTextResponse -Value $Value -ContentType 'text/xml' -StatusCode $StatusCode
}
<#
.SYNOPSIS
Renders a dynamic, or static, View on the Response.
.DESCRIPTION
Renders a dynamic, or static, View on the Response; allowing for dynamic data to be supplied.
.PARAMETER Path
The path to a View, relative to the "/views" directory. (Extension is optional).
.PARAMETER Data
Any dynamic data to supply to a dynamic View.
.PARAMETER StatusCode
The status code to set against the response.
.PARAMETER Folder
If supplied, a custom views folder will be used.
.PARAMETER FlashMessages
Automatically supply all Flash messages in the current session to the View.
.EXAMPLE
Write-PodeViewResponse -Path 'index'
.EXAMPLE
Write-PodeViewResponse -Path 'accounts/profile_page' -Data @{ Username = 'Morty' }
.EXAMPLE
Write-PodeViewResponse -Path 'login' -FlashMessages
#>
function Write-PodeViewResponse
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Path,
[Parameter()]
[hashtable]
$Data = @{},
[Parameter()]
[int]
$StatusCode = 200,
[Parameter()]
[string]
$Folder,
[switch]
$FlashMessages
)
# default data if null
if ($null -eq $Data) {
$Data = @{}
}
# add path to data as "pagename" - unless key already exists
if (!$Data.ContainsKey('pagename')) {
$Data['pagename'] = $Path
}
# load all flash messages if needed
if ($FlashMessages -and ($null -ne $WebEvent.Session.Data.Flash)) {
$Data['flash'] = @{}
foreach ($name in (Get-PodeFlashMessageNames)) {
$Data.flash[$name] = (Get-PodeFlashMessage -Name $name)
}
}
elseif ($null -eq $Data['flash']) {
$Data['flash'] = @{}
}
# add view engine extension
$ext = Get-PodeFileExtension -Path $Path
if ([string]::IsNullOrWhiteSpace($ext)) {
$Path += ".$($PodeContext.Server.ViewEngine.Extension)"
}
# only look in the view directories
$viewFolder = $PodeContext.Server.InbuiltDrives['views']
if (![string]::IsNullOrWhiteSpace($Folder)) {
$viewFolder = $PodeContext.Server.Views[$Folder]
}
$Path = (Join-Path $viewFolder $Path)
# test the file path, and set status accordingly
if (!(Test-PodePath $Path)) {
return
}
# run any engine logic and render it
$engine = (Get-PodeViewEngineType -Path $Path)
$value = (Get-PodeFileContentUsingViewEngine -Path $Path -Data $Data)
switch ($engine.ToLowerInvariant()) {
'md' {
Write-PodeMarkdownResponse -Value $value -StatusCode $StatusCode -AsHtml
}
default {
Write-PodeHtmlResponse -Value $value -StatusCode $StatusCode
}
}
}
<#
.SYNOPSIS
Sets the Status Code of the Response, and controls rendering error pages.
.DESCRIPTION
Sets the Status Code of the Response, and controls rendering error pages.
.PARAMETER Code
The Status Code to set on the Response.
.PARAMETER Description
An optional Status Description.
.PARAMETER Exception
An exception to use when detailing error information on error pages.
.PARAMETER ContentType
The content type of the error page to use.
.PARAMETER NoErrorPage
Don't render an error page when the Status Code is 400+.
.EXAMPLE
Set-PodeResponseStatus -Code 404
.EXAMPLE
Set-PodeResponseStatus -Code 500 -Exception $_.Exception
.EXAMPLE
Set-PodeResponseStatus -Code 500 -Exception $_.Exception -ContentType 'application/json'
#>
function Set-PodeResponseStatus
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[int]
$Code,
[Parameter()]
[string]
$Description,
[Parameter()]
$Exception,
[Parameter()]
[string]
$ContentType = $null,
[switch]
$NoErrorPage
)
# set the code
$WebEvent.Response.StatusCode = $Code
# set an appropriate description (mapping if supplied is blank)
if ([string]::IsNullOrWhiteSpace($Description)) {
$Description = (Get-PodeStatusDescription -StatusCode $Code)
}
if (!$PodeContext.Server.IsServerless -and ![string]::IsNullOrWhiteSpace($Description)) {
$WebEvent.Response.StatusDescription = $Description
}
# if the status code is >=400 then attempt to load error page
if (!$NoErrorPage -and ($Code -ge 400)) {
Show-PodeErrorPage -Code $Code -Description $Description -Exception $Exception -ContentType $ContentType
}
}
<#
.SYNOPSIS
Redirecting a user to a new URL.
.DESCRIPTION
Redirecting a user to a new URL, or the same URL as the Request but a different Protocol - or other components.
.PARAMETER Url
Redirect the user to a new URL, or a relative path.
.PARAMETER EndpointName
The Name of an Endpoint to redirect to.
.PARAMETER Port
Change the port of the current Request before redirecting.
.PARAMETER Protocol
Change the protocol of the current Request before redirecting.
.PARAMETER Address
Change the domain address of the current Request before redirecting.
.PARAMETER Moved
Set the Status Code as "301 Moved", rather than "302 Redirect".
.EXAMPLE
Move-PodeResponseUrl -Url 'https://google.com'
.EXAMPLE
Move-PodeResponseUrl -Url '/about'
.EXAMPLE
Move-PodeResponseUrl -Protocol HTTPS
.EXAMPLE
Move-PodeResponseUrl -Port 9000 -Moved
#>
function Move-PodeResponseUrl
{
[CmdletBinding(DefaultParameterSetName='Url')]
param(
[Parameter(Mandatory=$true, ParameterSetName='Url')]
[string]
$Url,
[Parameter(ParameterSetName='Endpoint')]
[string]
$EndpointName,
[Parameter(ParameterSetName='Components')]
[int]
$Port = 0,
[Parameter(ParameterSetName='Components')]
[ValidateSet('', 'Http', 'Https')]
[string]
$Protocol,
[Parameter(ParameterSetName='Components')]
[string]
$Address,
[switch]
$Moved
)
# build the url
if ($PSCmdlet.ParameterSetName -ieq 'components') {
$uri = $WebEvent.Request.Url
# set the protocol
$Protocol = $Protocol.ToLowerInvariant()
if ([string]::IsNullOrWhiteSpace($Protocol)) {
$Protocol = $uri.Scheme
}
# set the domain
if ([string]::IsNullOrWhiteSpace($Address)) {
$Address = $uri.Host
}
# set the port
if ($Port -le 0) {
$Port = $uri.Port
}
$PortStr = [string]::Empty
if (@(80, 443) -notcontains $Port) {
$PortStr = ":$($Port)"
}
# combine to form the url
$Url = "$($Protocol)://$($Address)$($PortStr)$($uri.PathAndQuery)"
}
# build the url from an endpoint
elseif ($PSCmdlet.ParameterSetName -ieq 'endpoint') {
$endpoint = Get-PodeEndpointByName -Name $EndpointName -ThrowError
# set the port
$PortStr = [string]::Empty
if (@(80, 443) -notcontains $endpoint.Port) {
$PortStr = ":$($endpoint.Port)"
}
$Url = "$($endpoint.Protocol)://$($endpoint.FriendlyName)$($PortStr)$($WebEvent.Request.Url.PathAndQuery)"
}
Set-PodeHeader -Name 'Location' -Value $Url
if ($Moved) {
Set-PodeResponseStatus -Code 301 -Description 'Moved'
}
else {
Set-PodeResponseStatus -Code 302 -Description 'Redirect'
}
}
<#
.SYNOPSIS
Writes data to a TCP Client stream.
.DESCRIPTION
Writes data to a TCP Client stream.
.PARAMETER Message
Parameter description
.PARAMETER Client
An optional TcpClient to write data.
.EXAMPLE
Write-PodeTcpClient -Message '250 OK'
#>
function Write-PodeTcpClient
{
[CmdletBinding()]
param (
[Parameter(ValueFromPipeline=$true)]
[string]
$Message,
[Parameter()]
$Client
)
# error if serverless
Test-PodeIsServerless -FunctionName 'Write-PodeTcpClient' -ThrowError
# use the main client if one isn't supplied
if ($null -eq $Client) {
$Client = $TcpEvent.Client
}
$encoder = New-Object System.Text.ASCIIEncoding
$buffer = $encoder.GetBytes("$($Message)`r`n")
$stream = $Client.GetStream()
Wait-PodeTask -Task $stream.WriteAsync($buffer, 0, $buffer.Length)
$stream.Flush()
}
<#
.SYNOPSIS
Reads data from a TCP Client stream.
.DESCRIPTION
Reads data from a TCP Client stream.
.PARAMETER Client
An optional TcpClient from which to read data.
.PARAMETER Timeout
An optional Timeout in milliseconds.
.EXAMPLE
$data = Read-PodeTcpClient
#>
function Read-PodeTcpClient
{
[CmdletBinding()]
[OutputType([string])]
param (
[Parameter()]
$Client,
[Parameter()]
[int]
$Timeout = 0
)
# error if serverless
Test-PodeIsServerless -FunctionName 'Read-PodeTcpClient' -ThrowError
# use the main client if one isn't supplied
if ($null -eq $Client) {
$Client = $TcpEvent.Client
}
# read the data from the stream
$bytes = New-Object byte[] 8192
$data = [string]::Empty
$encoder = New-Object System.Text.ASCIIEncoding
$stream = $Client.GetStream()
do {
$bytesRead = (Wait-PodeTask -Task $stream.ReadAsync($bytes, 0, $bytes.Length) -Timeout $Timeout)
$data += $encoder.GetString($bytes, 0, $bytesRead)
} while ($stream.DataAvailable)
return $data
}
<#
.SYNOPSIS
Saves an uploaded file on the Request to the File System.
.DESCRIPTION
Saves an uploaded file on the Request to the File System.
.PARAMETER Key
The name of the key within the web event's Data HashTable that stores the file's name.
.PARAMETER Path
The path to save files.
.EXAMPLE
Save-PodeRequestFile -Key 'avatar'
.EXAMPLE
Save-PodeRequestFile -Key 'avatar' -Path 'F:/Images'
#>
function Save-PodeRequestFile
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Key,
[Parameter()]
[string]
$Path = '.'
)
# if path is '.', replace with server root
$Path = Get-PodeRelativePath -Path $Path -JoinRoot
# ensure the parameter name exists in data
$fileName = $WebEvent.Data[$Key]
if ([string]::IsNullOrWhiteSpace($fileName)) {
throw "A parameter called '$($Key)' was not supplied in the request"
}
# ensure the file data exists
if (!$WebEvent.Files.ContainsKey($fileName)) {
throw "No data for file '$($fileName)' was uploaded in the request"
}
# if the path is a directory, add the filename
if (Test-PodePathIsDirectory -Path $Path) {
$Path = Join-Path $Path $fileName
}
# save the file
[System.IO.File]::WriteAllBytes($Path, $WebEvent.Files[$fileName].Bytes)
}
<#
.SYNOPSIS
Short description
.DESCRIPTION
Long description
.PARAMETER Type
The type name of the view engine (inbuilt types are: Pode and HTML).
.PARAMETER ScriptBlock
A ScriptBlock for specifying custom view engine rendering rules.
.PARAMETER Extension
A custom extension for the engine's files.
.EXAMPLE
Set-PodeViewEngine -Type HTML
.EXAMPLE
Set-PodeViewEngine -Type Markdown
.EXAMPLE
Set-PodeViewEngine -Type PSHTML -Extension PS1 -ScriptBlock { param($path, $data) /* logic */ }
#>
function Set-PodeViewEngine
{
[CmdletBinding()]
param (
[Parameter()]
[string]
$Type,
[Parameter()]
[scriptblock]
$ScriptBlock = $null,
[Parameter()]
[string]
$Extension
)
# truncate markdown
if ($Type -ieq 'Markdown') {
$Type = 'md'
}
# override extension with type
if ([string]::IsNullOrWhiteSpace($Extension)) {
$Extension = $Type.ToLowerInvariant()
}
# check if the scriptblock has any using vars
if ($null -ne $ScriptBlock) {
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
}
# setup view engine config
$PodeContext.Server.ViewEngine.Type = $Type.ToLowerInvariant()
$PodeContext.Server.ViewEngine.Extension = $Extension
$PodeContext.Server.ViewEngine.ScriptBlock = $ScriptBlock
$PodeContext.Server.ViewEngine.UsingVariables = $usingVars
$PodeContext.Server.ViewEngine.IsDynamic = (@('html', 'md') -inotcontains $Type)
}
<#
.SYNOPSIS
Includes the contents of a partial View into another dynamic View.
.DESCRIPTION
Includes the contents of a partial View into another dynamic View. The partial View can be static or dynamic.
.PARAMETER Path
The path to a partial View, relative to the "/views" directory. (Extension is optional).
.PARAMETER Data
Any dynamic data to supply to a dynamic partial View.
.PARAMETER Folder
If supplied, a custom views folder will be used.
.EXAMPLE
Use-PodePartialView -Path 'shared/footer'
#>
function Use-PodePartialView
{
[CmdletBinding()]
[OutputType([string])]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[string]
$Path,
[Parameter()]
$Data = @{},
[Parameter()]
[string]
$Folder
)
# default data if null
if ($null -eq $Data) {
$Data = @{}
}
# add view engine extension
$ext = Get-PodeFileExtension -Path $Path
if ([string]::IsNullOrWhiteSpace($ext)) {
$Path += ".$($PodeContext.Server.ViewEngine.Extension)"
}
# only look in the view directory
$viewFolder = $PodeContext.Server.InbuiltDrives['views']
if (![string]::IsNullOrWhiteSpace($Folder)) {
$viewFolder = $PodeContext.Server.Views[$Folder]
}
$Path = (Join-Path $viewFolder $Path)
# test the file path, and set status accordingly
if (!(Test-PodePath $Path -NoStatus)) {
throw "File not found at path: $($Path)"
}
# run any engine logic
return (Get-PodeFileContentUsingViewEngine -Path $Path -Data $Data)
}
<#
.SYNOPSIS
Broadcasts a message to connected WebSocket clients.
.DESCRIPTION
Broadcasts a message to all, or some, connected WebSocket clients. You can specify a path to send messages to, or a specific ClientId.
.PARAMETER Value
A String, PSObject, or HashTable value. For non-string values, they will be converted to JSON.
.PARAMETER Path
The Path of connected clients to send the message.
.PARAMETER ClientId
A specific ClientId of a connected client to send a message. Not currently used.
.PARAMETER Depth
The Depth to generate the JSON document - the larger this value the worse performance gets.
.EXAMPLE
Send-PodeSignal -Value @{ Message = 'Hello, world!' }
.EXAMPLE
Send-PodeSignal -Value @{ Data = @(123, 100, 101) } -Path '/response-charts'
#>
function Send-PodeSignal
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
$Value,
[Parameter()]
[string]
$Path,
[Parameter()]
[string]
$ClientId,
[Parameter()]
[int]
$Depth = 10
)
if ($null -eq $PodeContext.Server.WebSockets.Listener) {
throw "WebSockets have not been configured to send signal messages"
}
if ($Value -isnot [string]) {
if ($Depth -le 0) {
$Value = ($Value | ConvertTo-Json -Compress)
}
else {
$Value = ($Value | ConvertTo-Json -Depth $Depth -Compress)
}
}
$PodeContext.Server.WebSockets.Listener.AddServerSignal($Value, $Path, $ClientId)
}
<#
.SYNOPSIS
Add a custom path that contains additional views.
.DESCRIPTION
Add a custom path that contains additional views.
.PARAMETER Name
The Name of the views folder.
.PARAMETER Source
The literal, or relative, path to the directory that contains views.
.EXAMPLE
Add-PodeViewFolder -Name 'assets' -Source './assets'
#>
function Add-PodeViewFolder
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true)]
[string]
$Source
)
# ensure the folder doesn't already exist
if ($PodeContext.Server.Views.ContainsKey($Name)) {
throw "The Views folder name already exists: $($Name)"
}
# ensure the path exists at server root
$Source = Get-PodeRelativePath -Path $Source -JoinRoot
if (!(Test-PodePath -Path $Source -NoStatus)) {
throw "The Views path does not exist: $($Source)"
}
# setup a temp drive for the path
$Source = New-PodePSDrive -Path $Source
# add the route(s)
Write-Verbose "Adding View Folder: [$($Name)] $($Source)"
$PodeContext.Server.Views[$Name] = $Source
}
<#
.SYNOPSIS
Adds a Route for a specific HTTP Method.
.DESCRIPTION
Adds a Route for a specific HTTP Method, with path, that when called with invoke any logic and/or Middleware.
.PARAMETER Method
The HTTP Method of this Route.
.PARAMETER Path
The URI path for the Route.
.PARAMETER Middleware
An array of ScriptBlocks for optional Middleware.
.PARAMETER ScriptBlock
A ScriptBlock for the Route's main logic.
.PARAMETER EndpointName
The EndpointName of an Endpoint(s) this Route should be bound against.
.PARAMETER ContentType
The content type the Route should use when parsing any payloads.
.PARAMETER TransferEncoding
The transfer encoding the Route should use when parsing any payloads.
.PARAMETER ErrorContentType
The content type of any error pages that may get returned.
.PARAMETER FilePath
A literal, or relative, path to a file containing a ScriptBlock for the Route's main logic.
.PARAMETER ArgumentList
An array of arguments to supply to the Route's ScriptBlock.
.PARAMETER Authentication
The name of an Authentication method which should be used as middleware on this Route.
.PARAMETER Login
If supplied, the Route will be flagged to Authentication as being a Route that handles user logins.
.PARAMETER Logout
If supplied, the Route will be flagged to Authentication as being a Route that handles users logging out.
.PARAMETER PassThru
If supplied, the route created will be returned so it can be passed through a pipe.
.EXAMPLE
Add-PodeRoute -Method Get -Path '/' -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeRoute -Method Post -Path '/users/:userId/message' -Middleware (Get-PodeCsrfMiddleware) -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeRoute -Method Post -Path '/user' -ContentType 'application/json' -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeRoute -Method Post -Path '/user' -ContentType 'application/json' -TransferEncoding gzip -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeRoute -Method Get -Path '/api/cpu' -ErrorContentType 'application/json' -ScriptBlock { /* logic */ }
.EXAMPLE
Add-PodeRoute -Method Get -Path '/' -ScriptBlock { /* logic */ } -ArgumentList 'arg1', 'arg2'
#>
function Add-PodeRoute
{
[CmdletBinding(DefaultParameterSetName='Script')]
param(
[Parameter(Mandatory=$true)]
[ValidateSet('Delete', 'Get', 'Head', 'Merge', 'Options', 'Patch', 'Post', 'Put', 'Trace', '*')]
[string]
$Method,
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[object[]]
$Middleware,
[Parameter(ParameterSetName='Script')]
[scriptblock]
$ScriptBlock,
[Parameter()]
[string[]]
$EndpointName,
[Parameter()]
[string]
$ContentType,
[Parameter()]
[ValidateSet('', 'gzip', 'deflate')]
[string]
$TransferEncoding,
[Parameter()]
[string]
$ErrorContentType,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$FilePath,
[Parameter()]
[object[]]
$ArgumentList,
[Parameter()]
[Alias('Auth')]
[string]
$Authentication,
[switch]
$Login,
[switch]
$Logout,
[switch]
$PassThru
)
# split route on '?' for query
$Path = Split-PodeRouteQuery -Path $Path
if ([string]::IsNullOrWhiteSpace($Path)) {
throw "[$($Method)]: No Path supplied for Route"
}
# ensure the route has appropriate slashes
$Path = Update-PodeRouteSlashes -Path $Path
$OpenApiPath = ConvertTo-PodeOpenApiRoutePath -Path $Path
$Path = Update-PodeRoutePlaceholders -Path $Path
# get endpoints from name
if (!$PodeContext.Server.FindRouteEndpoint) {
$PodeContext.Server.FindRouteEndpoint = !(Test-PodeIsEmpty $EndpointName)
}
$endpoints = Find-PodeEndpoints -EndpointName $EndpointName
# ensure the route doesn't already exist for each endpoint
foreach ($_endpoint in $endpoints) {
Test-PodeRouteAndError -Method $Method -Path $Path -Protocol $_endpoint.Protocol -Address $_endpoint.Address
}
# if middleware, scriptblock and file path are all null/empty, error
if ((Test-PodeIsEmpty $Middleware) -and (Test-PodeIsEmpty $ScriptBlock) -and (Test-PodeIsEmpty $FilePath) -and (Test-PodeIsEmpty $Authentication)) {
throw "[$($Method)] $($Path): No logic passed"
}
# if we have a file path supplied, load that path as a scriptblock
if ($PSCmdlet.ParameterSetName -ieq 'file') {
$ScriptBlock = Convert-PodeFileToScriptBlock -FilePath $FilePath
}
# check if the scriptblock has any using vars
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
# convert any middleware into valid hashtables
$Middleware = @(ConvertTo-PodeRouteMiddleware -Method $Method -Path $Path -Middleware $Middleware -PSSession $PSCmdlet.SessionState)
# if an auth name was supplied, setup the auth as the first middleware
if (![string]::IsNullOrWhiteSpace($Authentication)) {
if (!(Test-PodeAuth -Name $Authentication)) {
throw "Authentication method does not exist: $($Authentication)"
}
$options = @{
Name = $Authentication
Login = $Login
Logout = $Logout
}
$Middleware = (@(Get-PodeAuthMiddlewareScript | New-PodeMiddleware -ArgumentList $options) + $Middleware)
}
# workout a default content type for the route
$ContentType = Find-PodeRouteContentType -Path $Path -ContentType $ContentType
# workout a default transfer encoding for the route
$TransferEncoding = Find-PodeRouteTransferEncoding -Path $Path -TransferEncoding $TransferEncoding
# add the route(s)
Write-Verbose "Adding Route: [$($Method)] $($Path)"
$newRoutes = @(foreach ($_endpoint in $endpoints) {
@{
Logic = $ScriptBlock
UsingVariables = $usingVars
Middleware = $Middleware
Authentication = $Authentication
Endpoint = @{
Protocol = $_endpoint.Protocol
Address = $_endpoint.Address.Trim()
Name = $_endpoint.Name
}
ContentType = $ContentType
TransferEncoding = $TransferEncoding
ErrorType = $ErrorContentType
Arguments = $ArgumentList
Method = $Method
Path = $Path
OpenApi = @{
Path = $OpenApiPath
Responses = @{
'200' = @{ description = 'OK' }
'default' = @{ description = 'Internal server error' }
}
Parameters = @()
RequestBody = @{}
Authentication = @()
}
IsStatic = $false
Metrics = @{
Requests = @{
Total = 0
StatusCodes = @{}
}
}
}
})
if (![string]::IsNullOrWhiteSpace($Authentication)) {
Set-PodeOAAuth -Route $newRoutes -Name $Authentication
}
$PodeContext.Server.Routes[$Method][$Path] += @($newRoutes)
# return the routes?
if ($PassThru) {
return $newRoutes
}
}
<#
.SYNOPSIS
Add a static Route for rendering static content.
.DESCRIPTION
Add a static Route for rendering static content. You can also define default pages to display.
.PARAMETER Path
The URI path for the static Route.
.PARAMETER Source
The literal, or relative, path to the directory that contains the static content.
.PARAMETER Middleware
An array of ScriptBlocks for optional Middleware.
.PARAMETER EndpointName
The EndpointName of an Endpoint(s) to bind the static Route against.
.PARAMETER ContentType
The content type the static Route should use when parsing any payloads.
.PARAMETER TransferEncoding
The transfer encoding the static Route should use when parsing any payloads.
.PARAMETER Defaults
An array of default pages to display, such as 'index.html'.
.PARAMETER ErrorContentType
The content type of any error pages that may get returned.
.PARAMETER Authentication
The name of an Authentication method which should be used as middleware on this Route.
.PARAMETER DownloadOnly
When supplied, all static content on this Route will be attached as downloads - rather than rendered.
.PARAMETER PassThru
If supplied, the static route created will be returned so it can be passed through a pipe.
.EXAMPLE
Add-PodeStaticRoute -Path '/assets' -Source './assets'
.EXAMPLE
Add-PodeStaticRoute -Path '/assets' -Source './assets' -Defaults @('index.html')
.EXAMPLE
Add-PodeStaticRoute -Path '/installers' -Source './exes' -DownloadOnly
#>
function Add-PodeStaticRoute
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter(Mandatory=$true)]
[string]
$Source,
[Parameter()]
[object[]]
$Middleware,
[Parameter()]
[string[]]
$EndpointName,
[Parameter()]
[string]
$ContentType,
[Parameter()]
[ValidateSet('', 'gzip', 'deflate')]
[string]
$TransferEncoding,
[Parameter()]
[string[]]
$Defaults,
[Parameter()]
[string]
$ErrorContentType,
[Parameter()]
[Alias('Auth')]
[string]
$Authentication,
[switch]
$DownloadOnly,
[switch]
$PassThru
)
# store the route method
$Method = 'Static'
# split route on '?' for query
$Path = Split-PodeRouteQuery -Path $Path
if ([string]::IsNullOrWhiteSpace($Path)) {
throw "[$($Method)]: No Path path supplied for Static Route"
}
# ensure the route has appropriate slashes
$Path = Update-PodeRouteSlashes -Path $Path -Static
$OpenApiPath = ConvertTo-PodeOpenApiRoutePath -Path $Path
$Path = Update-PodeRoutePlaceholders -Path $Path
# get endpoints from name
if (!$PodeContext.Server.FindRouteEndpoint) {
$PodeContext.Server.FindRouteEndpoint = !(Test-PodeIsEmpty $EndpointName)
}
$endpoints = Find-PodeEndpoints -EndpointName $EndpointName
# ensure the route doesn't already exist for each endpoint
foreach ($_endpoint in $endpoints) {
Test-PodeRouteAndError -Method $Method -Path $Path -Protocol $_endpoint.Protocol -Address $_endpoint.Address
}
# if static, ensure the path exists at server root
$Source = Get-PodeRelativePath -Path $Source -JoinRoot
if (!(Test-PodePath -Path $Source -NoStatus)) {
throw "[$($Method))] $($Path): The Source path supplied for Static Route does not exist: $($Source)"
}
# setup a temp drive for the path
$Source = New-PodePSDrive -Path $Source
# setup default static files
if ($null -eq $Defaults) {
$Defaults = Get-PodeStaticRouteDefaults
}
# convert any middleware into valid hashtables
$Middleware = @(ConvertTo-PodeRouteMiddleware -Method $Method -Path $Path -Middleware $Middleware -PSSession $PSCmdlet.SessionState)
# if an auth name was supplied, setup the auth as the first middleware
if (![string]::IsNullOrWhiteSpace($Authentication)) {
if (!(Test-PodeAuth -Name $Authentication)) {
throw "Authentication method does not exist: $($Authentication)"
}
$options = @{ Name = $Authentication }
$Middleware = (@(Get-PodeAuthMiddlewareScript | New-PodeMiddleware -ArgumentList $options) + $Middleware)
}
# workout a default content type for the route
$ContentType = Find-PodeRouteContentType -Path $Path -ContentType $ContentType
# workout a default transfer encoding for the route
$TransferEncoding = Find-PodeRouteTransferEncoding -Path $Path -TransferEncoding $TransferEncoding
# add the route(s)
Write-Verbose "Adding Route: [$($Method)] $($Path)"
$newRoutes = @(foreach ($_endpoint in $endpoints) {
@{
Source = $Source
Path = $Path
Method = $Method
Defaults = $Defaults
Middleware = $Middleware
Endpoint = @{
Protocol = $_endpoint.Protocol
Address = $_endpoint.Address.Trim()
Name = $_endpoint.Name
}
ContentType = $ContentType
TransferEncoding = $TransferEncoding
ErrorType = $ErrorContentType
Download = $DownloadOnly
OpenApi = @{
Path = $OpenApiPath
Responses = @{
'200' = @{ description = 'OK' }
'default' = @{ description = 'Internal server error' }
}
Parameters = @()
RequestBody = @{}
Authentication = @()
}
IsStatic = $true
Metrics = @{
Requests = @{
Total = 0
StatusCodes = @{}
}
}
}
})
if (![string]::IsNullOrWhiteSpace($Authentication)) {
Set-PodeOAAuth -Route $newRoutes -Name $Authentication
}
$PodeContext.Server.Routes[$Method][$Path] += @($newRoutes)
# return the routes?
if ($PassThru) {
return $newRoutes
}
}
<#
.SYNOPSIS
Remove a specific Route.
.DESCRIPTION
Remove a specific Route.
.PARAMETER Method
The method of the Route to remove.
.PARAMETER Path
The path of the Route to remove.
.PARAMETER EndpointName
The EndpointName of an Endpoint(s) bound to the Route to be removed.
.EXAMPLE
Remove-PodeRoute -Method Get -Route '/about'
.EXAMPLE
Remove-PodeRoute -Method Post -Route '/users/:userId' -EndpointName User
#>
function Remove-PodeRoute
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[ValidateSet('Delete', 'Get', 'Head', 'Merge', 'Options', 'Patch', 'Post', 'Put', 'Trace', '*')]
[string]
$Method,
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[string]
$EndpointName
)
# split route on '?' for query
$Path = Split-PodeRouteQuery -Path $Path
if ([string]::IsNullOrWhiteSpace($Path)) {
throw "[$($Method)]: No Route path supplied for removing a Route"
}
# ensure the route has appropriate slashes and replace parameters
$Path = Update-PodeRouteSlashes -Path $Path
$Path = Update-PodeRoutePlaceholders -Path $Path
# ensure route does exist
if (!$PodeContext.Server.Routes[$Method].ContainsKey($Path)) {
return
}
# remove the route's logic
$PodeContext.Server.Routes[$Method][$Path] = @($PodeContext.Server.Routes[$Method][$Path] | Where-Object {
$_.Endpoint.Name -ine $EndpointName
})
# if the route has no more logic, just remove it
if ((Get-PodeCount $PodeContext.Server.Routes[$Method][$Path]) -eq 0) {
$PodeContext.Server.Routes[$Method].Remove($Path) | Out-Null
}
}
<#
.SYNOPSIS
Remove a specific static Route.
.DESCRIPTION
Remove a specific static Route.
.PARAMETER Path
The path of the static Route to remove.
.PARAMETER EndpointName
The EndpointName of an Endpoint(s) bound to the static Route to be removed.
.EXAMPLE
Remove-PodeStaticRoute -Path '/assets'
#>
function Remove-PodeStaticRoute
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[string]
$EndpointName
)
$Method = 'Static'
# ensure the route has appropriate slashes and replace parameters
$Path = Update-PodeRouteSlashes -Path $Path -Static
# ensure route does exist
if (!$PodeContext.Server.Routes[$Method].ContainsKey($Path)) {
return
}
# remove the route's logic
$PodeContext.Server.Routes[$Method][$Path] = @($PodeContext.Server.Routes[$Method][$Path] | Where-Object {
$_.Endpoint.Name -ine $EndpointName
})
# if the route has no more logic, just remove it
if ((Get-PodeCount $PodeContext.Server.Routes[$Method][$Path]) -eq 0) {
$PodeContext.Server.Routes[$Method].Remove($Path) | Out-Null
}
}
<#
.SYNOPSIS
Removes all added Routes, or Routes for a specific Method.
.DESCRIPTION
Removes all added Routes, or Routes for a specific Method.
.PARAMETER Method
The Method to from which to remove all Routes.
.EXAMPLE
Clear-PodeRoutes
.EXAMPLE
Clear-PodeRoutes -Method Get
#>
function Clear-PodeRoutes
{
[CmdletBinding()]
param (
[Parameter()]
[ValidateSet('', 'Delete', 'Get', 'Head', 'Merge', 'Options', 'Patch', 'Post', 'Put', 'Trace', '*')]
[string]
$Method
)
if (![string]::IsNullOrWhiteSpace($Method)) {
$PodeContext.Server.Routes[$Method].Clear()
}
else {
$PodeContext.Server.Routes.Keys.Clone() | ForEach-Object {
$PodeContext.Server.Routes[$_].Clear()
}
}
}
<#
.SYNOPSIS
Removes all added static Routes.
.DESCRIPTION
Removes all added static Routes.
.EXAMPLE
Clear-PodeStaticRoutes
#>
function Clear-PodeStaticRoutes
{
[CmdletBinding()]
param()
$PodeContext.Server.Routes['Static'].Clear()
}
<#
.SYNOPSIS
Takes an array of Commands, or a Module, and converts them into Routes.
.DESCRIPTION
Takes an array of Commands (Functions/Aliases), or a Module, and generates appropriate Routes for the commands.
.PARAMETER Commands
An array of Commands to convert - if a Module is supplied, these Commands must be present within that Module.
.PARAMETER Module
A Module whose exported commands will be converted.
.PARAMETER Method
An override HTTP method to use when generating the Routes. If not supplied, Pode will make a best guess based on the Command's Verb.
.PARAMETER Path
An optional Path for the Route, to prepend before the Command Name and Module.
.PARAMETER Middleware
Like normal Routes, an array of Middleware that will be applied to all generated Routes.
.PARAMETER Authentication
The name of an Authentication method which should be used as middleware on this Route.
.PARAMETER NoVerb
If supplied, the Command's Verb will not be included in the Route's path.
.PARAMETER NoOpenApi
If supplied, no OpenAPI definitions will be generated for the routes created.
.EXAMPLE
ConvertTo-PodeRoute -Commands @('Get-ChildItem', 'Get-Host', 'Invoke-Expression') -Middleware { ... }
.EXAMPLE
ConvertTo-PodeRoute -Commands @('Get-ChildItem', 'Get-Host', 'Invoke-Expression') -Authentication AuthName
.EXAMPLE
ConvertTo-PodeRoute -Module Pester -Path '/api'
.EXAMPLE
ConvertTo-PodeRoute -Commands @('Invoke-Pester') -Module Pester
#>
function ConvertTo-PodeRoute
{
[CmdletBinding()]
param (
[Parameter(ValueFromPipeline=$true)]
[string[]]
$Commands,
[Parameter()]
[string]
$Module,
[Parameter()]
[ValidateSet('', 'Delete', 'Get', 'Head', 'Merge', 'Options', 'Patch', 'Post', 'Put', 'Trace')]
[string]
$Method,
[Parameter()]
[string]
$Path = '/',
[Parameter()]
[object[]]
$Middleware,
[Parameter()]
[Alias('Auth')]
[string]
$Authentication,
[switch]
$NoVerb,
[switch]
$NoOpenApi
)
# if a module was supplied, import it - then validate the commands
if (![string]::IsNullOrWhiteSpace($Module)) {
Import-PodeModule -Name $Module
Write-Verbose "Getting exported commands from module"
$ModuleCommands = (Get-Module -Name $Module | Sort-Object -Descending | Select-Object -First 1).ExportedCommands.Keys
# if commands were supplied validate them - otherwise use all exported ones
if (Test-PodeIsEmpty $Commands) {
Write-Verbose "Using all commands in $($Module) for converting to routes"
$Commands = $ModuleCommands
}
else {
Write-Verbose "Validating supplied commands against module's exported commands"
foreach ($cmd in $Commands) {
if ($ModuleCommands -inotcontains $cmd) {
throw "Module $($Module) does not contain function $($cmd) to convert to a Route"
}
}
}
}
# if there are no commands, fail
if (Test-PodeIsEmpty $Commands) {
throw 'No commands supplied to convert to Routes'
}
# trim end trailing slashes from the path
$Path = Protect-PodeValue -Value $Path -Default '/'
$Path = $Path.TrimEnd('/')
# create the routes for each of the commands
foreach ($cmd in $Commands) {
# get module verb/noun and comvert verb to HTTP method
$split = ($cmd -split '\-')
if ($split.Length -ge 2) {
$verb = $split[0]
$noun = $split[1..($split.Length - 1)] -join ([string]::Empty)
}
else {
$verb = [string]::Empty
$noun = $split[0]
}
# determine the http method, or use the one passed
$_method = $Method
if ([string]::IsNullOrWhiteSpace($_method)) {
$_method = Convert-PodeFunctionVerbToHttpMethod -Verb $verb
}
# use the full function name, or remove the verb
$name = $cmd
if ($NoVerb) {
$name = $noun
}
# build the route's path
$_path = ("$($Path)/$($Module)/$($name)" -replace '[/]+', '/')
# create the route
$route = (Add-PodeRoute -Method $_method -Path $_path -Middleware $Middleware -Authentication $Authentication -ArgumentList $cmd -ScriptBlock {
param($cmd)
# either get params from the QueryString or Payload
if ($WebEvent.Method -ieq 'get') {
$parameters = $WebEvent.Query
}
else {
$parameters = $WebEvent.Data
}
# invoke the function
$result = (. $cmd @parameters)
# if we have a result, convert it to json
if (!(Test-PodeIsEmpty $result)) {
Write-PodeJsonResponse -Value $result -Depth 1
}
} -PassThru)
# set the openapi metadata of the function, unless told to skip
if ($NoOpenApi) {
continue
}
$help = Get-Help -Name $cmd
$route = ($route | Set-PodeOARouteInfo -Summary $help.Synopsis -Tags $Module -PassThru)
# set the routes parameters (get = query, everything else = payload)
$params = (Get-Command -Name $cmd).Parameters
if (($null -eq $params) -or ($params.Count -eq 0)) {
continue
}
$props = @(foreach ($key in $params.Keys) {
$params[$key] | ConvertTo-PodeOAPropertyFromCmdletParameter
})
if ($_method -ieq 'get') {
$route | Set-PodeOARequest -Parameters @(foreach ($prop in $props) { $prop | ConvertTo-PodeOAParameter -In Query })
}
else {
$route | Set-PodeOARequest -RequestBody (
New-PodeOARequestBody -ContentSchemas @{ 'application/json' = (New-PodeOAObjectProperty -Array -Properties $props) }
)
}
}
}
<#
.SYNOPSIS
Helper function to generate simple GET routes.
.DESCRIPTION
Helper function to generate simple GET routes from ScritpBlocks, Files, and Views.
The output is always rendered as HTML.
.PARAMETER Name
A unique name for the page, that will be used in the Path for the route.
.PARAMETER ScriptBlock
A ScriptBlock to invoke, where any results will be converted to HTML.
.PARAMETER FilePath
A FilePath, literal or relative, to a valid HTML file.
.PARAMETER View
The name of a View to render, this can be HTML or Dynamic.
.PARAMETER Data
A hashtable of Data to supply to a Dynamic File/View, or to be splatted as arguments for the ScriptBlock.
.PARAMETER Path
An optional Path for the Route, to prepend before the Name.
.PARAMETER Middleware
Like normal Routes, an array of Middleware that will be applied to all generated Routes.
.PARAMETER Authentication
The name of an Authentication method which should be used as middleware on this Route.
.PARAMETER FlashMessages
If supplied, Views will have any flash messages supplied to them for rendering.
.EXAMPLE
Add-PodePage -Name Services -ScriptBlock { Get-Service }
.EXAMPLE
Add-PodePage -Name Index -View 'index'
.EXAMPLE
Add-PodePage -Name About -FilePath '.\views\about.pode' -Data @{ Date = [DateTime]::UtcNow }
#>
function Add-PodePage
{
[CmdletBinding(DefaultParameterSetName='ScriptBlock')]
param (
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[string]
$Name,
[Parameter(Mandatory=$true, ParameterSetName='ScriptBlock')]
[scriptblock]
$ScriptBlock,
[Parameter(Mandatory=$true, ParameterSetName='File')]
[string]
$FilePath,
[Parameter(Mandatory=$true, ParameterSetName='View')]
[string]
$View,
[Parameter()]
[hashtable]
$Data,
[Parameter()]
[string]
$Path = '/',
[Parameter()]
[object[]]
$Middleware,
[Parameter()]
[Alias('Auth')]
[string]
$Authentication,
[Parameter(ParameterSetName='View')]
[switch]
$FlashMessages
)
$logic = $null
$arg = $null
# ensure the name is a valid alphanumeric
if ($Name -inotmatch '^[a-z0-9\-_]+$') {
throw "The Page name should be a valid AlphaNumeric value: $($Name)"
}
# trim end trailing slashes from the path
$Path = Protect-PodeValue -Value $Path -Default '/'
$Path = $Path.TrimEnd('/')
# define the appropriate logic
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant())
{
'scriptblock' {
if (Test-PodeIsEmpty $ScriptBlock){
throw 'A non-empty ScriptBlock is required to created a Page Route'
}
$arg = @($ScriptBlock, $Data)
$logic = {
param($script, $data)
# invoke the function (optional splat data)
if (Test-PodeIsEmpty $data) {
$result = (. $script)
}
else {
$result = (. $script @data)
}
# if we have a result, convert it to html
if (!(Test-PodeIsEmpty $result)) {
Write-PodeHtmlResponse -Value $result
}
}
}
'file' {
$FilePath = Get-PodeRelativePath -Path $FilePath -JoinRoot -TestPath
$arg = @($FilePath, $Data)
$logic = {
param($file, $data)
Write-PodeFileResponse -Path $file -ContentType 'text/html' -Data $data
}
}
'view' {
$arg = @($View, $Data, $FlashMessages)
$logic = {
param($view, $data, [bool]$flash)
Write-PodeViewResponse -Path $view -Data $data -FlashMessages:$flash
}
}
}
# build the route's path
$_path = ("$($Path)/$($Name)" -replace '[/]+', '/')
# create the route
Add-PodeRoute `
-Method Get `
-Path $_path `
-Middleware $Middleware `
-Authentication $Authentication `
-ArgumentList $arg `
-ScriptBlock $logic
}
<#
.SYNOPSIS
Get a Route(s).
.DESCRIPTION
Get a Route(s).
.PARAMETER Method
A Method to filter the routes.
.PARAMETER Path
A Path to filter the routes.
.PARAMETER EndpointName
The name of an endpoint to filter routes.
.EXAMPLE
Get-PodeRoute -Method Get -Route '/about'
.EXAMPLE
Get-PodeRoute -Method Post -Route '/users/:userId' -EndpointName User
#>
function Get-PodeRoute
{
[CmdletBinding()]
param (
[Parameter()]
[ValidateSet('', 'Delete', 'Get', 'Head', 'Merge', 'Options', 'Patch', 'Post', 'Put', 'Trace', '*')]
[string]
$Method,
[Parameter()]
[string]
$Path,
[Parameter()]
[string[]]
$EndpointName
)
# start off with every route
$routes = @()
foreach ($route in $PodeContext.Server.Routes.Values.Values) {
$routes += $route
}
# if we have a method, filter
if (![string]::IsNullOrWhiteSpace($Method)) {
$routes = @(foreach ($route in $routes) {
if ($route.Method -ine $Method) {
continue
}
$route
})
}
# if we have a path, filter
if (![string]::IsNullOrWhiteSpace($Path)) {
$Path = Split-PodeRouteQuery -Path $Path
$Path = Update-PodeRouteSlashes -Path $Path
$Path = Update-PodeRoutePlaceholders -Path $Path
$routes = @(foreach ($route in $routes) {
if ($route.Path -ine $Path) {
continue
}
$route
})
}
# further filter by endpoint names
if (($null -ne $EndpointName) -and ($EndpointName.Length -gt 0)) {
$routes = @(foreach ($name in $EndpointName) {
foreach ($route in $routes) {
if ($route.Endpoint.Name -ine $name) {
continue
}
$route
}
})
}
# return
return $routes
}
<#
.SYNOPSIS
Get a static Route(s).
.DESCRIPTION
Get a static Route(s).
.PARAMETER Path
A Path to filter the static routes.
.PARAMETER EndpointName
The name of an endpoint to filter static routes.
.EXAMPLE
Get-PodeStaticRoute -Path '/assets'
.EXAMPLE
Get-PodeStaticRoute -Path '/assets' -EndpointName User
#>
function Get-PodeStaticRoute
{
[CmdletBinding()]
param (
[Parameter()]
[string]
$Path,
[Parameter()]
[string[]]
$EndpointName
)
# start off with every route
$routes = @()
foreach ($route in $PodeContext.Server.Routes['Static'].Values) {
$routes += $route
}
# if we have a path, filter
if (![string]::IsNullOrWhiteSpace($Path)) {
$Path = Update-PodeRouteSlashes -Path $Path -Static
$routes = @(foreach ($route in $routes) {
if ($route.Path -ine $Path) {
continue
}
$route
})
}
# further filter by endpoint names
if (($null -ne $EndpointName) -and ($EndpointName.Length -gt 0)) {
$routes = @(foreach ($name in $EndpointName) {
foreach ($route in $routes) {
if ($route.Endpoint.Name -ine $name) {
continue
}
$route
}
})
}
# return
return $routes
}
<#
.SYNOPSIS
Sets an object within the shared state.
.DESCRIPTION
Sets an object within the shared state.
.PARAMETER Name
The name of the state object.
.PARAMETER Value
The value to set in the state.
.PARAMETER Scope
An optional Scope for the state object, used when saving the state.
.EXAMPLE
Set-PodeState -Name 'Data' -Value @{ 'Name' = 'Rick Sanchez' }
.EXAMPLE
Set-PodeState -Name 'Users' -Value @('user1', 'user2') -Scope General, Users
#>
function Set-PodeState
{
[CmdletBinding()]
[OutputType([object])]
param(
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(ValueFromPipeline=$true)]
[object]
$Value,
[Parameter()]
[string[]]
$Scope
)
if ($null -eq $PodeContext.Server.State) {
throw "Pode has not been initialised"
}
if ($null -eq $Scope) {
$Scope = @()
}
$PodeContext.Server.State[$Name] = @{
Value = $Value
Scope = $Scope
}
return $Value
}
<#
.SYNOPSIS
Retrieves some state object from the shared state.
.DESCRIPTION
Retrieves some state object from the shared state.
.PARAMETER Name
The name of the state object.
.PARAMETER WithScope
If supplied, the state's value and scope will be returned as a hashtable.
.EXAMPLE
Get-PodeState -Name 'Data'
#>
function Get-PodeState
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]
$Name,
[switch]
$WithScope
)
if ($null -eq $PodeContext.Server.State) {
throw "Pode has not been initialised"
}
if ($WithScope) {
return $PodeContext.Server.State[$Name]
}
else {
return $PodeContext.Server.State[$Name].Value
}
}
<#
.SYNOPSIS
Removes some state object from the shared state.
.DESCRIPTION
Removes some state object from the shared state. After removal, the original object being stored is returned.
.PARAMETER Name
The name of the state object.
.EXAMPLE
Remove-PodeState -Name 'Data'
#>
function Remove-PodeState
{
[CmdletBinding()]
[OutputType([object])]
param(
[Parameter(Mandatory=$true)]
[string]
$Name
)
if ($null -eq $PodeContext.Server.State) {
throw "Pode has not been initialised"
}
$value = $PodeContext.Server.State[$Name].Value
$PodeContext.Server.State.Remove($Name) | Out-Null
return $value
}
<#
.SYNOPSIS
Saves the current shared state to a supplied JSON file.
.DESCRIPTION
Saves the current shared state to a supplied JSON file. When using this function, it's recommended to wrap it in a Lock-PodeObject block.
.PARAMETER Path
The path to a JSON file which the current state will be saved to.
.PARAMETER Scope
An optional array of scopes for state objects that should be saved. (This has a lower precedence than Exclude/Include)
.PARAMETER Exclude
An optional array of state object names to exclude from being saved. (This has a higher precedence than Include)
.PARAMETER Include
An optional array of state object names to only include when being saved.
.EXAMPLE
Save-PodeState -Path './state.json'
.EXAMPLE
Save-PodeState -Path './state.json' -Exclude Name1, Name2
.EXAMPLE
Save-PodeState -Path './state.json' -Scope Users
#>
function Save-PodeState
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]
$Path,
[Parameter()]
[string[]]
$Scope,
[Parameter()]
[string[]]
$Exclude,
[Parameter()]
[string[]]
$Include
)
# error if attempting to use outside of the pode server
if ($null -eq $PodeContext.Server.State) {
throw "Pode has not been initialised"
}
# get the full path to save the state
$Path = Get-PodeRelativePath -Path $Path -JoinRoot
# contruct the state to save (excludes, etc)
$state = $PodeContext.Server.State.Clone()
# scopes
if (($null -ne $Scope) -and ($Scope.Length -gt 0)) {
foreach ($_key in $state.Clone().Keys) {
# remove if no scope
if (($null -eq $state[$_key].Scope) -or ($state[$_key].Scope.Length -eq 0)) {
$state.Remove($_key) | Out-Null
continue
}
# check scopes (only remove if none match)
$found = $false
foreach ($_scope in $state[$_key].Scope) {
if ($Scope -icontains $_scope) {
$found = $true
break
}
}
if ($found) {
continue
}
# none matched, remove
$state.Remove($_key) | Out-Null
}
}
# include keys
if (($null -ne $Include) -and ($Include.Length -gt 0)) {
foreach ($_key in $state.Clone().Keys) {
if ($Include -inotcontains $_key) {
$state.Remove($_key) | Out-Null
}
}
}
# exclude keys
if (($null -ne $Exclude) -and ($Exclude.Length -gt 0)) {
foreach ($_key in $state.Clone().Keys) {
if ($Exclude -icontains $_key) {
$state.Remove($_key) | Out-Null
}
}
}
# save the state
$state | ConvertTo-Json -Depth 10 | Out-File -FilePath $Path -Force | Out-Null
}
<#
.SYNOPSIS
Restores the shared state from some JSON file.
.DESCRIPTION
Restores the shared state from some JSON file.
.PARAMETER Path
The path to a JSON file that contains the state information.
.EXAMPLE
Restore-PodeState -Path './state.json'
#>
function Restore-PodeState
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true)]
[string]
$Path
)
# error if attempting to use outside of the pode server
if ($null -eq $PodeContext.Server.State) {
throw "Pode has not been initialised"
}
# get the full path to the state
$Path = Get-PodeRelativePath -Path $Path -JoinRoot
if (!(Test-Path $Path)) {
return
}
# restore the state from file
$state = @{}
if (Test-PodeIsPSCore) {
$state = (Get-Content $Path -Force | ConvertFrom-Json -AsHashtable -Depth 10)
}
else {
$props = (Get-Content $Path -Force | ConvertFrom-Json).psobject.properties
foreach ($prop in $props) {
$state[$prop.Name] = $prop.Value
}
}
# check for no scopes, and add for backwards compat
$convert = $false
foreach ($_key in $state.Clone().Keys) {
if ($null -eq $state[$_key].Scope) {
$convert = $true
break
}
}
if ($convert) {
foreach ($_key in $state.Clone().Keys) {
$state[$_key] = @{
Value = $state[$_key]
Scope = @()
}
}
}
# set the scope to the main context
$PodeContext.Server.State = $state.Clone()
}
<#
.SYNOPSIS
Tests if the shared state contains some state object.
.DESCRIPTION
Tests if the shared state contains some state object.
.PARAMETER Name
The name of the state object.
.EXAMPLE
Test-PodeState -Name 'Data'
#>
function Test-PodeState
{
[CmdletBinding()]
[OutputType([bool])]
param(
[Parameter(Mandatory=$true)]
[string]
$Name
)
if ($null -eq $PodeContext.Server.State) {
throw "Pode has not been initialised"
}
return $PodeContext.Server.State.ContainsKey($Name)
}
<#
.SYNOPSIS
Waits for a task to finish, and returns a result if there is one.
.DESCRIPTION
Waits for a task to finish, and returns a result if there is one.
.PARAMETER Task
The task to wait on.
.PARAMETER Timeout
An optional Timeout in milliseconds.
.EXAMPLE
$context = Wait-PodeTask -Task $listener.GetContextAsync()
#>
function Wait-PodeTask
{
[CmdletBinding()]
[OutputType([object])]
param (
[Parameter(Mandatory=$true)]
[System.Threading.Tasks.Task]
$Task,
[Parameter()]
[int]
$Timeout = 0
)
# do we need a timeout?
$timeoutTask = $null
if ($Timeout -gt 0) {
$timeoutTask = [System.Threading.Tasks.Task]::Delay($Timeout)
}
# set the check task
if ($null -eq $timeoutTask) {
$checkTask = $Task
}
else {
$checkTask = [System.Threading.Tasks.Task]::WhenAny($Task, $timeoutTask)
}
# is there a cancel token to supply?
if (($null -eq $PodeContext) -or ($null -eq $PodeContext.Tokens.Cancellation.Token)) {
$checkTask.Wait()
}
else {
$checkTask.Wait($PodeContext.Tokens.Cancellation.Token)
}
# if the main task isnt complete, it timed out
if (($null -ne $timeoutTask) -and (!$Task.IsCompleted)) {
throw [System.TimeoutException]::new("Task has timed out after $($Timeout)ms")
}
# only return a value if the result has one
if ($null -ne $Task.Result) {
return $Task.Result
}
}
<#
.SYNOPSIS
Dispose and close streams, tokens, and other Disposables.
.DESCRIPTION
Dispose and close streams, tokens, and other Disposables.
.PARAMETER Disposable
The Disposable object to dispose and close.
.PARAMETER Close
Should the Disposable also be closed, as well as disposed?
.PARAMETER CheckNetwork
If an error is thrown, check the reason - if it's network related ignore the error.
.EXAMPLE
Close-PodeDisposable -Disposable $stream -Close
#>
function Close-PodeDisposable
{
[CmdletBinding()]
param (
[Parameter()]
[System.IDisposable]
$Disposable,
[switch]
$Close,
[switch]
$CheckNetwork
)
if ($null -eq $Disposable) {
return
}
try {
if ($Close) {
$Disposable.Close()
}
}
catch [exception] {
if ($CheckNetwork -and (Test-PodeValidNetworkFailure $_.Exception)) {
return
}
$_ | Write-PodeErrorLog
throw $_.Exception
}
finally {
$Disposable.Dispose()
}
}
<#
.SYNOPSIS
Places a temporary lock on a object while a ScriptBlock is invoked.
.DESCRIPTION
Places a temporary lock on a object while a ScriptBlock is invoked.
.PARAMETER Object
The object to lock.
.PARAMETER ScriptBlock
The ScriptBlock to invoke.
.PARAMETER Return
If supplied, any values from the ScriptBlock will be returned.
.EXAMPLE
Lock-PodeObject -Object $SomeArray -ScriptBlock { /* logic */ }
.EXAMPLE
$result = (Lock-PodeObject -Return -Object $SomeArray -ScriptBlock { /* logic */ })
#>
function Lock-PodeObject
{
[CmdletBinding()]
[OutputType([object])]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[object]
$Object,
[Parameter(Mandatory=$true)]
[scriptblock]
$ScriptBlock,
[switch]
$Return
)
if ($null -eq $Object) {
return
}
if ($Object -is [valuetype]) {
throw 'Cannot lock value types'
}
$locked = $false
try {
[System.Threading.Monitor]::Enter($Object.SyncRoot)
$locked = $true
if ($null -ne $ScriptBlock) {
if ($Return) {
return (Invoke-PodeScriptBlock -ScriptBlock $ScriptBlock -NoNewClosure -Return)
}
else {
Invoke-PodeScriptBlock -ScriptBlock $ScriptBlock -NoNewClosure
}
}
}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
finally {
if ($locked) {
[System.Threading.Monitor]::Pulse($Object.SyncRoot)
[System.Threading.Monitor]::Exit($Object.SyncRoot)
}
}
}
<#
.SYNOPSIS
Returns the literal path of the server.
.DESCRIPTION
Returns the literal path of the server.
.EXAMPLE
$path = Get-PodeServerPath
#>
function Get-PodeServerPath
{
[CmdletBinding()]
[OutputType([string])]
param()
return $PodeContext.Server.Root
}
<#
.SYNOPSIS
Starts a Stopwatch on some ScriptBlock, and outputs the duration at the end.
.DESCRIPTION
Starts a Stopwatch on some ScriptBlock, and outputs the duration at the end.
.PARAMETER Name
The name of the Stopwatch.
.PARAMETER ScriptBlock
The ScriptBlock to time.
.EXAMPLE
Start-PodeStopwatch -Name 'ReadFile' -ScriptBlock { $content = Get-Content './file.txt' }
#>
function Start-PodeStopwatch
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Name,
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[scriptblock]
$ScriptBlock
)
try {
$watch = [System.Diagnostics.Stopwatch]::StartNew()
. $ScriptBlock
}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
finally {
$watch.Stop()
"[Stopwatch]: $($watch.Elapsed) [$($Name)]" | Out-PodeHost
}
}
<#
.SYNOPSIS
Like the "using" keyword in .NET. Allows you to use a Stream and then disposes of it.
.DESCRIPTION
Like the "using" keyword in .NET. Allows you to use a Stream and then disposes of it.
.PARAMETER Stream
The Stream to use and then dispose.
.PARAMETER ScriptBlock
The ScriptBlock to invoke. It will be supplied the Stream.
.EXAMPLE
$content = (Use-PodeStream -Stream $stream -ScriptBlock { return $args[0].ReadToEnd() })
#>
function Use-PodeStream
{
[CmdletBinding()]
[OutputType([object])]
param (
[Parameter(Mandatory=$true)]
[System.IDisposable]
$Stream,
[Parameter(Mandatory=$true)]
[scriptblock]
$ScriptBlock
)
try {
return (Invoke-PodeScriptBlock -ScriptBlock $ScriptBlock -Arguments $Stream -Return -NoNewClosure)
}
catch {
$_ | Write-PodeErrorLog
throw $_.Exception
}
finally {
$Stream.Dispose()
}
}
<#
.SYNOPSIS
Loads a script, by dot-sourcing, at the supplied path.
.DESCRIPTION
Loads a script, by dot-sourcing, at the supplied path. If the path is relative, the server's path is prepended.
.PARAMETER Path
The path, literal or relative to the server, to some script.
.EXAMPLE
Use-PodeScript -Path './scripts/tools.ps1'
#>
function Use-PodeScript
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Path
)
# if path is '.', replace with server root
$_path = Get-PodeRelativePath -Path $Path -JoinRoot -Resolve
# we have a path, if it's a directory/wildcard then loop over all files
if (![string]::IsNullOrWhiteSpace($_path)) {
$_paths = Get-PodeWildcardFiles -Path $Path -Wildcard '*.ps1'
if (!(Test-PodeIsEmpty $_paths)) {
foreach ($_path in $_paths) {
Use-PodeScript -Path $_path
}
return
}
}
# check if the path exists
if (!(Test-PodePath $_path -NoStatus)) {
throw "The script path does not exist: $(Protect-PodeValue -Value $_path -Default $Path)"
}
# dot-source the script
. $_path
# load any functions from the file into pode's runspaces
Import-PodeFunctionsIntoRunspaceState -FilePath $_path
}
<#
.SYNOPSIS
Returns the loaded configuration of the server.
.DESCRIPTION
Returns the loaded configuration of the server.
.EXAMPLE
$s = Get-PodeConfig
#>
function Get-PodeConfig
{
[CmdletBinding()]
[OutputType([hashtable])]
param()
return $PodeContext.Server.Configuration
}
<#
.SYNOPSIS
Adds a ScriptBlock as Endware to run at the end of each web Request.
.DESCRIPTION
Adds a ScriptBlock as Endware to run at the end of each web Request.
.PARAMETER ScriptBlock
The ScriptBlock to add. It will be supplied the current web event.
.PARAMETER ArgumentList
An array of arguments to supply to the Endware's ScriptBlock.
.EXAMPLE
Add-PodeEndware -ScriptBlock { /* logic */ }
#>
function Add-PodeEndware
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[scriptblock]
$ScriptBlock,
[Parameter()]
[object[]]
$ArgumentList
)
# check if the scriptblock has any using vars
$ScriptBlock, $usingVars = Invoke-PodeUsingScriptConversion -ScriptBlock $ScriptBlock -PSSession $PSCmdlet.SessionState
# add the scriptblock to array of endware that needs to be run
$PodeContext.Server.Endware += @{
Logic = $ScriptBlock
UsingVariables = $usingVars
Arguments = $ArgumentList
}
}
<#
.SYNOPSIS
Imports a Module into the current, and all runspaces that Pode uses.
.DESCRIPTION
Imports a Module into the current, and all runspaces that Pode uses. Modules can also be imported from the ps_modules directory.
.PARAMETER Name
The name of a globally installed Module, or one within the ps_modules directory, to import.
.PARAMETER Path
The path, literal or relative, to a Module to import.
.EXAMPLE
Import-PodeModule -Name IISManager
.EXAMPLE
Import-PodeModule -Path './modules/utilities.psm1'
#>
function Import-PodeModule
{
[CmdletBinding(DefaultParameterSetName='Name')]
param(
[Parameter(Mandatory=$true, ParameterSetName='Name')]
[string]
$Name,
[Parameter(Mandatory=$true, ParameterSetName='Path')]
[string]
$Path
)
# script root path
$rootPath = $null
if ($null -eq $PodeContext) {
$rootPath = (Protect-PodeValue -Value $MyInvocation.PSScriptRoot -Default $pwd.Path)
}
# get the path of a module, or import modules on mass
switch ($PSCmdlet.ParameterSetName.ToLowerInvariant()) {
'name' {
$modulePath = Join-PodeServerRoot -Folder (Join-PodePaths @('ps_modules', $Name)) -Root $rootPath
if (Test-PodePath -Path $modulePath -NoStatus) {
$Path = (Get-ChildItem (Join-PodePaths @($modulePath, '*', "$($Name).ps*1")) -Recurse -Force | Select-Object -First 1).FullName
}
else {
$Path = (Get-Module -Name $Name -ListAvailable | Select-Object -First 1).Path
}
}
'path' {
$Path = Get-PodeRelativePath -Path $Path -RootPath $rootPath -JoinRoot -Resolve
$paths = Get-PodeWildcardFiles -Path $Path -RootPath $rootPath -Wildcard '*.ps*1'
if (!(Test-PodeIsEmpty $paths)) {
foreach ($_path in $paths) {
Import-PodeModule -Path $_path
}
return
}
}
}
# if it's still empty, error
if ([string]::IsNullOrWhiteSpace($Path)) {
throw "Failed to import module: $(Protect-PodeValue -Value $Path -Default $Name)"
}
# check if the path exists
if (!(Test-PodePath $Path -NoStatus)) {
throw "The module path does not exist: $(Protect-PodeValue -Value $Path -Default $Name)"
}
Import-Module $Path -Force -DisableNameChecking -Scope Global -ErrorAction Stop | Out-Null
}
<#
.SYNOPSIS
Imports a Snapin into the current, and all runspaces that Pode uses.
.DESCRIPTION
Imports a Snapin into the current, and all runspaces that Pode uses.
.PARAMETER Name
The name of a Snapin to import.
.EXAMPLE
Import-PodeSnapin -Name 'WDeploySnapin3.0'
#>
function Import-PodeSnapin
{
[CmdletBinding()]
param (
[Parameter(Mandatory=$true)]
[string]
$Name
)
# if non-windows or core, fail
if ((Test-PodeIsPSCore) -or (Test-PodeIsUnix)) {
throw 'Snapins are only supported on Windows PowerShell'
}
# import the snap-in
Add-PSSnapin -Name $Name | Out-Null
}
<#
.SYNOPSIS
Protects a value, by returning a default value is the main one is null/empty.
.DESCRIPTION
Protects a value, by returning a default value is the main one is null/empty.
.PARAMETER Value
The main value to use.
.PARAMETER Default
A default value to return should the main value be null/empty.
.EXAMPLE
$Name = Protect-PodeValue -Value $Name -Default 'Rick'
#>
function Protect-PodeValue
{
[CmdletBinding()]
[OutputType([object])]
param (
[Parameter()]
$Value,
[Parameter()]
$Default
)
return (Resolve-PodeValue -Check (Test-PodeIsEmpty $Value) -TrueValue $Default -FalseValue $Value)
}
<#
.SYNOPSIS
Resolves a query, and returns a value based on the response.
.DESCRIPTION
Resolves a query, and returns a value based on the response.
.PARAMETER Check
The query, or variable, to evalulate.
.PARAMETER TrueValue
The value to use if evaluated to True.
.PARAMETER FalseValue
The value to use if evaluated to False.
.EXAMPLE
$Port = Resolve-PodeValue -Check $AllowSsl -TrueValue 443 -FalseValue -80
#>
function Resolve-PodeValue
{
[CmdletBinding()]
[OutputType([object])]
param (
[Parameter(Mandatory=$true)]
[bool]
$Check,
[Parameter()]
$TrueValue,
[Parameter()]
$FalseValue
)
if ($Check) {
return $TrueValue
}
return $FalseValue
}
<#
.SYNOPSIS
Invokes a ScriptBlock.
.DESCRIPTION
Invokes a ScriptBlock, supplying optional arguments, splatting, and returning any optional values.
.PARAMETER ScriptBlock
The ScriptBlock to invoke.
.PARAMETER Arguments
Any arguments that should be supplied to the ScriptBlock.
.PARAMETER Scoped
Run the ScriptBlock in a scoped context.
.PARAMETER Return
Return any values that the ScriptBlock may return.
.PARAMETER Splat
Spat the argument onto the ScriptBlock.
.PARAMETER NoNewClosure
Don't create a new closure before invoking the ScriptBlock.
.EXAMPLE
Invoke-PodeScriptBlock -ScriptBlock { Write-Host 'Hello!' }
.EXAMPLE
Invoke-PodeScriptBlock -Arguments 'Morty' -ScriptBlock { /* logic */ }
#>
function Invoke-PodeScriptBlock
{
[CmdletBinding()]
[OutputType([object])]
param (
[Parameter(Mandatory=$true)]
[scriptblock]
$ScriptBlock,
[Parameter()]
$Arguments = $null,
[switch]
$Scoped,
[switch]
$Return,
[switch]
$Splat,
[switch]
$NoNewClosure
)
if ($PodeContext.Server.IsServerless) {
$NoNewClosure = $true
}
if (!$NoNewClosure) {
$ScriptBlock = ($ScriptBlock).GetNewClosure()
}
if ($Scoped) {
if ($Splat) {
$result = (& $ScriptBlock @Arguments)
}
else {
$result = (& $ScriptBlock $Arguments)
}
}
else {
if ($Splat) {
$result = (. $ScriptBlock @Arguments)
}
else {
$result = (. $ScriptBlock $Arguments)
}
}
if ($Return) {
return $result
}
}
<#
.SYNOPSIS
Tests if a value is empty - the value can be of any type.
.DESCRIPTION
Tests if a value is empty - the value can be of any type.
.PARAMETER Value
The value to test.
.EXAMPLE
if (Test-PodeIsEmpty @{}) { /* logic */ }
#>
function Test-PodeIsEmpty
{
[CmdletBinding()]
[OutputType([bool])]
param (
[Parameter()]
$Value
)
if ($null -eq $Value) {
return $true
}
if ($Value -is [string]) {
return [string]::IsNullOrWhiteSpace($Value)
}
if ($Value -is [array]) {
return ($Value.Length -eq 0)
}
if ($Value -is [hashtable]) {
return ($Value.Count -eq 0)
}
if ($Value -is [scriptblock]) {
return ([string]::IsNullOrWhiteSpace($Value.ToString()))
}
if ($Value -is [valuetype]) {
return $false
}
return ([string]::IsNullOrWhiteSpace($Value) -or ((Get-PodeCount $Value) -eq 0))
}
<#
.SYNOPSIS
Tests if the the current session is running in PowerShell Core.
.DESCRIPTION
Tests if the the current session is running in PowerShell Core.
.EXAMPLE
if (Test-PodeIsPSCore) { /* logic */ }
#>
function Test-PodeIsPSCore
{
[CmdletBinding()]
[OutputType([bool])]
param()
return (Get-PodePSVersionTable).PSEdition -ieq 'core'
}
<#
.SYNOPSIS
Tests if the current OS is Unix.
.DESCRIPTION
Tests if the current OS is Unix.
.EXAMPLE
if (Test-PodeIsUnix) { /* logic */ }
#>
function Test-PodeIsUnix
{
[CmdletBinding()]
[OutputType([bool])]
param()
return (Get-PodePSVersionTable).Platform -ieq 'unix'
}
<#
.SYNOPSIS
Tests if the current OS is Windows.
.DESCRIPTION
Tests if the current OS is Windows.
.EXAMPLE
if (Test-PodeIsWindows) { /* logic */ }
#>
function Test-PodeIsWindows
{
[CmdletBinding()]
[OutputType([bool])]
param()
$v = Get-PodePSVersionTable
return ($v.Platform -ilike '*win*' -or ($null -eq $v.Platform -and $v.PSEdition -ieq 'desktop'))
}
<#
.SYNOPSIS
Outputs an object to the main Host.
.DESCRIPTION
Due to Pode's use of runspaces, this will output a given object back to the main Host.
It's advised to use this function, so that any output respects the -Quiet flag of the server.
.PARAMETER InputObject
The object to output.
.EXAMPLE
'Hello, world!' | Out-PodeHost
.EXAMPLE
@{ Name = 'Rick' } | Out-PodeHost
#>
function Out-PodeHost
{
[CmdletBinding()]
param(
[Parameter(Mandatory=$true, ValueFromPipeline=$true)]
[object]
$InputObject
)
if (!$PodeContext.Server.Quiet) {
$InputObject | Out-Default
}
}
<#
.SYNOPSIS
Writes an object to the Host.
.DESCRIPTION
Writes an object to the Host.
It's advised to use this function, so that any output respects the -Quiet flag of the server.
.PARAMETER Object
The object to write.
.PARAMETER ForegroundColor
An optional foreground colour.
.PARAMETER NoNewLine
Whether or not to write a new line.
.EXAMPLE
'Some output' | Write-PodeHost -ForegroundColor Cyan
#>
function Write-PodeHost
{
[CmdletBinding()]
param(
[Parameter(Position=0, ValueFromPipeline=$true)]
[object]
$Object,
[Parameter()]
[System.ConsoleColor]
$ForegroundColor,
[switch]
$NoNewLine
)
if ($PodeContext.Server.Quiet) {
return
}
if ($ForegroundColor) {
Write-Host -Object $Object -ForegroundColor $ForegroundColor -NoNewline:$NoNewLine
}
else {
Write-Host -Object $Object -NoNewline:$NoNewLine
}
}
<#
.SYNOPSIS
Returns whether or not the server is running via IIS.
.DESCRIPTION
Returns whether or not the server is running via IIS.
.EXAMPLE
if (Test-PodeIsIIS) { }
#>
function Test-PodeIsIIS
{
[CmdletBinding()]
param()
return $PodeContext.Server.IsIIS
}
<#
.SYNOPSIS
Returns whether or not the server is running via Heroku.
.DESCRIPTION
Returns whether or not the server is running via Heroku.
.EXAMPLE
if (Test-PodeIsHeroku) { }
#>
function Test-PodeIsHeroku
{
[CmdletBinding()]
param()
return $PodeContext.Server.IsHeroku
}
VERIFICATION
Verification is intended to assist the Chocolatey moderators and community
in verifying that this package's contents are trustworthy.
This embedded PowerShell module is packaged and distributed by the author.
The contents of which can be found on the releases pages at <https://github.com/Badgerati/Pode/releases>.
To verify contents, either:
1. Compare the Checksum on the release notes against the Module's source.
2. Download the zip from the release, run 'checksum -t sha256' on it, and compare.
function Remove-PodeModule($path)
{
$path = Join-Path $path 'Pode'
if (Test-Path $path)
{
Write-Host "Deleting module directory: $($path)"
Remove-Item -Path $path -Recurse -Force | Out-Null
if (!$?) {
throw "Failed to delete: $path"
}
}
}
# Determine which Program Files path to use
$progFiles = [string]$env:ProgramFiles
# Remove PS Module
# Set the module path
$modulePath = Join-Path $progFiles (Join-Path 'WindowsPowerShell' 'Modules')
# Delete module
Remove-PodeModule $modulePath
# Remove PS-Core Module
$def = (Get-Command pwsh -ErrorAction SilentlyContinue).Definition
if (![string]::IsNullOrWhiteSpace($def))
{
# Set the module path
$modulePath = Join-Path $progFiles (Join-Path 'PowerShell' 'Modules')
# Delete module
Remove-PodeModule $modulePath
}
Log in or click on link to see number of positives.
- pode.2.1.1.nupkg (bb47568b6828) - ## / 63
- Pode.dll (b373939fe6ce) - ## / 68
In cases where actual malware is found, the packages are subject to removal. Software sometimes has false positives. Moderators do not necessarily validate the safety of the underlying software, only that a package retrieves software from the official distribution point and/or validate embedded software against official distribution point (where distribution rights allow redistribution).
Chocolatey Pro provides runtime protection from possible malware.
Add to Builder | Version | Downloads | Last Updated | Status |
---|---|---|---|---|
Pode 2.10.0 | 42 | Monday, April 15, 2024 | Approved | |
Pode 2.9.0 | 182 | Monday, October 30, 2023 | Approved | |
Pode 2.8.0 | 239 | Friday, February 3, 2023 | Approved | |
Pode 2.7.2 | 134 | Tuesday, October 25, 2022 | Approved | |
Pode 2.7.1 | 114 | Thursday, July 21, 2022 | Approved | |
Pode 2.7.0 | 124 | Wednesday, June 22, 2022 | Approved | |
Pode 2.6.2 | 167 | Wednesday, March 2, 2022 | Approved | |
Pode 2.6.1 | 88 | Monday, February 21, 2022 | Approved | |
Pode 2.6.0 | 90 | Thursday, February 10, 2022 | Approved | |
Pode 2.5.2 | 102 | Tuesday, January 4, 2022 | Approved | |
Pode 2.5.1 | 97 | Tuesday, December 21, 2021 | Approved | |
Pode 2.5.0 | 112 | Saturday, November 13, 2021 | Approved | |
Pode 2.4.2 | 130 | Monday, September 13, 2021 | Approved | |
Pode 2.4.1 | 115 | Monday, August 9, 2021 | Approved | |
Pode 2.4.0 | 95 | Wednesday, July 21, 2021 | Approved | |
Pode 2.3.0 | 120 | Tuesday, June 1, 2021 | Approved | |
Pode 2.2.3 | 137 | Saturday, April 10, 2021 | Approved | |
Pode 2.2.2 | 91 | Friday, April 9, 2021 | Approved | |
Pode 2.2.1 | 95 | Saturday, March 27, 2021 | Approved | |
Pode 2.2.0 | 112 | Sunday, March 21, 2021 | Approved | |
Pode 2.1.1 | 116 | Friday, February 19, 2021 | Approved | |
Pode 2.1.0 | 1165 | Wednesday, February 3, 2021 | Approved | |
Pode 2.0.3 | 151 | Monday, December 21, 2020 | Approved | |
Pode 2.0.2 | 122 | Saturday, December 5, 2020 | Approved | |
Pode 2.0.1 | 107 | Sunday, November 29, 2020 | Approved | |
Pode 2.0.0 | 177 | Saturday, November 14, 2020 | Approved | |
Pode 1.8.4 | 169 | Friday, October 16, 2020 | Approved | |
Pode 1.8.3 | 151 | Sunday, September 20, 2020 | Approved | |
Pode 1.8.2 | 193 | Friday, July 31, 2020 | Approved | |
Pode 1.8.1 | 170 | Friday, June 26, 2020 | Approved | |
Pode 1.8.0 | 182 | Sunday, May 24, 2020 | Approved | |
Pode 1.7.3 | 184 | Sunday, May 10, 2020 | Approved | |
Pode 1.7.2 | 163 | Monday, April 27, 2020 | Approved | |
Pode 1.7.1 | 157 | Friday, April 17, 2020 | Approved | |
Pode 1.7.0 | 174 | Friday, April 10, 2020 | Approved | |
Pode 1.6.1 | 225 | Saturday, March 7, 2020 | Approved | |
Pode 1.6.0 | 184 | Tuesday, March 3, 2020 | Approved | |
Pode 1.5.0 | 220 | Sunday, February 2, 2020 | Approved | |
Pode 1.4.0 | 196 | Friday, January 10, 2020 | Approved | |
Pode 1.3.0 | 182 | Friday, December 27, 2019 | Approved | |
Pode 1.2.1 | 200 | Monday, December 2, 2019 | Approved | |
Pode 1.2.0 | 190 | Wednesday, November 13, 2019 | Approved | |
Pode 1.1.0 | 204 | Saturday, September 28, 2019 | Approved | |
Pode 1.0.1 | 198 | Wednesday, September 4, 2019 | Approved | |
Pode 1.0.0 | 193 | Monday, September 2, 2019 | Approved | |
Pode 0.32.0 | 232 | Friday, June 28, 2019 | Approved | |
Pode 0.31.0 | 197 | Tuesday, June 11, 2019 | Approved | |
Pode 0.30.0 | 194 | Sunday, May 26, 2019 | Approved | |
Pode 0.29.0 | 193 | Friday, May 10, 2019 | Approved | |
Pode 0.28.1 | 229 | Tuesday, April 16, 2019 | Approved | |
Pode 0.28.0 | 182 | Saturday, April 13, 2019 | Approved | |
Pode 0.27.3 | 202 | Thursday, April 4, 2019 | Approved | |
Pode 0.27.2 | 219 | Wednesday, March 27, 2019 | Approved | |
Pode 0.27.1 | 214 | Saturday, March 16, 2019 | Approved | |
Pode 0.27.0 | 211 | Thursday, March 14, 2019 | Approved | |
Pode 0.26.0 | 234 | Sunday, February 17, 2019 | Approved | |
Pode 0.25.0 | 231 | Tuesday, February 5, 2019 | Approved | |
Pode 0.24.0 | 256 | Friday, January 18, 2019 | Approved | |
Pode 0.23.0 | 246 | Monday, December 24, 2018 | Approved | |
Pode 0.22.0 | 236 | Friday, December 7, 2018 | Approved | |
Pode 0.21.0 | 261 | Friday, November 2, 2018 | Approved | |
Pode 0.20.0 | 263 | Saturday, October 20, 2018 | Approved | |
Pode 0.19.1 | 230 | Tuesday, October 9, 2018 | Approved | |
Pode 0.19.0 | 245 | Friday, September 14, 2018 | Approved | |
Pode 0.18.0 | 235 | Saturday, August 25, 2018 | Approved | |
Pode 0.17.0 | 205 | Sunday, August 19, 2018 | Approved | |
Pode 0.16.0 | 253 | Wednesday, August 8, 2018 | Approved | |
Pode 0.15.0 | 276 | Friday, July 13, 2018 | Approved | |
Pode 0.14.0 | 251 | Friday, July 6, 2018 | Approved | |
Pode 0.13.0 | 250 | Saturday, June 23, 2018 | Approved | |
Pode 0.12.0 | 241 | Friday, June 15, 2018 | Approved | |
Pode 0.11.3 | 276 | Sunday, June 10, 2018 | Approved | |
Pode 0.11.2 | 272 | Friday, June 8, 2018 | Approved | |
Pode 0.11.1 | 295 | Friday, June 1, 2018 | Approved | |
Pode 0.11.0 | 263 | Wednesday, May 30, 2018 | Approved | |
Pode 0.10.1 | 312 | Wednesday, May 16, 2018 | Approved | |
Pode 0.9.0 | 337 | Thursday, January 11, 2018 | Approved |
Copyright 2017-2021
This package has no dependencies.
Ground Rules:
- This discussion is only about Pode and the Pode package. If you have feedback for Chocolatey, please contact the Google Group.
- This discussion will carry over multiple versions. If you have a comment about a particular version, please note that in your comments.
- The maintainers of this Chocolatey Package will be notified about new comments that are posted to this Disqus thread, however, it is NOT a guarantee that you will get a response. If you do not hear back from the maintainers after posting a message below, please follow up by using the link on the left side of this page or follow this link to contact maintainers. If you still hear nothing back, please follow the package triage process.
- Tell us what you love about the package or Pode, or tell us what needs improvement.
- Share your experiences with the package, or extra configuration or gotchas that you've found.
- If you use a url, the comment will be flagged for moderation until you've been whitelisted. Disqus moderated comments are approved on a weekly schedule if not sooner. It could take between 1-5 days for your comment to show up.