发表更新powershell / blockchain / automation2 分钟读完 (大约240个字)

PowerShell 技能连载 - 区块链智能合约自动化管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
function Invoke-SmartContractOperation {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$ContractABI,
        
        [ValidateSet('Deploy','Execute','Query')]
        [string]$OperationType = 'Query'
    )

    $blockchainReport = [PSCustomObject]@{
        Timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
        TransactionHash = $null
        GasUsed = 0
        ContractAddress = $null
    }

    try {
        # 初始化Web3实例
        $web3 = New-Web3 -ProviderUrl 'https://mainnet.infura.io/v3/YOUR-API-KEY'
        
        # 智能合约操作
        switch($OperationType) {
            'Deploy' {
                $txReceipt = $web3.Eth.DeployContract.SendRequestAsync($ContractABI).GetAwaiter().GetResult()
                $blockchainReport.ContractAddress = $txReceipt.ContractAddress
            }
            'Execute' {
                $contract = $web3.Eth.GetContract($ContractABI, $blockchainReport.ContractAddress)
                $function = $contract.GetFunction('executeOperation')
                $txHash = $function.SendTransactionAsync().GetAwaiter().GetResult()
                $blockchainReport.TransactionHash = $txHash
            }
            'Query' {
                $contract = $web3.Eth.GetContract($ContractABI, $blockchainReport.ContractAddress)
                $result = $contract.GetFunction('getState').CallAsync().GetAwaiter().GetResult()
                return $result
            }
        }

        # 获取Gas消耗
        $txReceipt = $web3.Eth.Transactions.GetTransactionReceipt.SendRequestAsync($blockchainReport.TransactionHash).GetAwaiter().GetResult()
        $blockchainReport.GasUsed = $txReceipt.GasUsed
    }
    catch {
        Write-Error "智能合约操作失败: $_"
    }

    # 生成区块链审计日志
    $blockchainReport | ConvertTo-Json | 
        Out-File -Path "$env:TEMP/BlockchainReport_$(Get-Date -Format yyyyMMdd).json"
    return $blockchainReport
}

核心功能：

  1. 智能合约自动化部署
  2. 交易执行与状态查询
  3. Gas消耗实时监控
  4. JSON格式审计日志

应用场景：

  • DeFi协议自动化管理
  • NFT数字资产发行
  • DAO治理流程自动化
  • 跨链桥接操作监控
发表更新powershell / devops1 分钟读完 (大约193个字)

PowerShell 技能连载 - 容器化脚本自动化管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
function Invoke-ContainerPipeline {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$ImageName,
        [string]$DockerfilePath = './Dockerfile'
    )

    $report = [PSCustomObject]@{
        Timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
        BuildLog = @()
        DeploymentStatus = @()
    }

    # 构建Docker镜像
    $buildOutput = docker build -t $ImageName -f $DockerfilePath . 2>&1
    $report.BuildLog += $buildOutput

    # 推送镜像到仓库
    if ($LASTEXITCODE -eq 0) {
        $pushOutput = docker push $ImageName 2>&1
        $report.BuildLog += $pushOutput
    }

    # 部署到Kubernetes
    if ($LASTEXITCODE -eq 0) {
        $k8sOutput = kubectl apply -f deployment.yaml 2>&1
        $report.DeploymentStatus += [PSCustomObject]@{
            Cluster = (kubectl config current-context)
            Status = if($LASTEXITCODE -eq 0){'Success'}else{'Failed'}
            Output = $k8sOutput
        }
    }

    # 生成HTML报告
    $htmlReport = $report | ConvertTo-Html -Fragment
    $htmlReport | Out-File "$env:TEMP/ContainerReport_$(Get-Date -Format yyyyMMdd).html"
    return $report
}

核心功能：

  1. Docker镜像自动化构建
  2. 容器仓库自动推送
  3. Kubernetes部署集成
  4. HTML运维报告生成

典型应用场景：

  • 持续集成/持续部署(CI/CD)
  • 跨环境容器镜像管理
  • 蓝绿部署策略实施
  • 容器化应用生命周期管理
发表更新powershell / energy2 分钟读完 (大约234个字)

PowerShell 技能连载 - 工业能源优化智能分析系统

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
function Optimize-IndustrialEnergy {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$DeviceEndpoint,
        
        [ValidateSet('Realtime','Historical')]
        [string]$AnalysisMode = 'Realtime'
    )

    $energyReport = [PSCustomObject]@{
        Timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
        PowerConsumption = @{}
        Predictions = @{}
        Anomalies = @()
    }

    try {
        # 实时能耗数据采集
        $liveData = Invoke-RestMethod -Uri "$DeviceEndpoint/api/live"
        $energyReport.PowerConsumption = $liveData.Measurements | 
            Group-Object DeviceID -AsHashTable

        # 历史数据分析模式
        if ($AnalysisMode -eq 'Historical') {
            $historicalData = Invoke-RestMethod -Uri "$DeviceEndpoint/api/history?days=30"
            $energyReport.Predictions = $historicalData | 
                ForEach-Object {
                    [PSCustomObject]@{
                        DeviceID = $_.DeviceID
                        PredictedUsage = [math]::Round($_.Baseline * (1 + (Get-Random -Minimum -0.1 -Maximum 0.1)),2)
                    }
                }
        }

        # 异常检测引擎
        $liveData.Measurements | ForEach-Object {
            if ($_.CurrentUsage -gt ($_.Baseline * 1.15)) {
                $energyReport.Anomalies += [PSCustomObject]@{
                    Device = $_.DeviceID
                    Metric = 'PowerOverload'
                    Actual = $_.CurrentUsage
                    Threshold = [math]::Round($_.Baseline * 1.15,2)
                }
            }
        }
    }
    catch {
        Write-Error "能源数据分析失败: $_"
    }

    # 生成优化建议报告
    $energyReport | Export-Clixml -Path "$env:TEMP/EnergyReport_$(Get-Date -Format yyyyMMdd).xml"
    return $energyReport
}

核心功能：

  1. 工业能耗实时/历史数据分析
  2. 智能基线预测模型
  3. 异常超限检测引擎
  4. XML格式优化报告生成

应用场景：

  • 工业控制系统能耗优化
  • 智能电网负载预测
  • 生产设备预防性维护
  • 碳足迹分析与管理
发表更新powershell / tip19 分钟读完 (大约2808个字)

PowerShell 技能连载 - 高级错误处理技术

在PowerShell脚本开发中，有效的错误处理是确保脚本健壮性和可靠性的关键。本文将介绍一系列高级错误处理技术，帮助您编写更专业的PowerShell脚本。

基础错误处理

首先，让我们回顾PowerShell中的基本错误处理机制：

1
2
3
4
5
6
7
8
9
10
11
12
13
# 使用try/catch/finally块处理错误
try {
    # 尝试执行的代码
    Get-Content -Path "C:\NonExistentFile.txt" -ErrorAction Stop
}
catch {
    # 错误处理代码
    Write-Host "发生错误: $($_.Exception.Message)" -ForegroundColor Red
}
finally {
    # 无论是否发生错误都会执行的代码
    Write-Host "操作完成" -ForegroundColor Yellow
}

使用$ErrorActionPreference

PowerShell的$ErrorActionPreference变量控制脚本遇到错误时的默认行为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 设置全局错误处理行为
$ErrorActionPreference = 'Stop'  # 遇到错误时停止执行
# 其他选项: Continue（默认），SilentlyContinue，Ignore，Inquire

# 代码块中临时改变错误处理行为
$originalEAP = $ErrorActionPreference
$ErrorActionPreference = 'SilentlyContinue'
try {
    # 尝试执行的代码，错误会被忽略
    Get-Process -Name "NonExistentProcess"
}
finally {
    # 恢复原始错误处理行为
    $ErrorActionPreference = $originalEAP
}

创建自定义错误记录器

下面是一个自定义错误记录函数，可帮助您以统一格式记录错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
function Write-ErrorLog {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [System.Management.Automation.ErrorRecord]$ErrorRecord,
        
        [Parameter()]
        [string]$LogPath = "C:\Logs\PowerShell_Errors.log",
        
        [Parameter()]
        [switch]$PassThru
    )
    
    # 确保日志目录存在
    $logDir = Split-Path -Path $LogPath -Parent
    if (-not (Test-Path -Path $logDir)) {
        New-Item -Path $logDir -ItemType Directory -Force | Out-Null
    }
    
    # 格式化错误信息
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $errorMessage = $ErrorRecord.Exception.Message
    $errorLine = $ErrorRecord.InvocationInfo.Line.Trim()
    $errorPosition = $ErrorRecord.InvocationInfo.PositionMessage
    $errorCategory = $ErrorRecord.CategoryInfo.Category
    $errorType = $ErrorRecord.Exception.GetType().FullName
    
    # 构建详细错误信息
    $logEntry = @"
[${timestamp}] 
ERROR TYPE: $errorType
CATEGORY: $errorCategory
MESSAGE: $errorMessage
LINE: $errorLine
POSITION: $errorPosition
STACK TRACE: 
$($ErrorRecord.ScriptStackTrace)
====================
"@
    
    # 记录到文件
    Add-Content -Path $LogPath -Value $logEntry
    
    # 输出给调用者
    if ($PassThru) {
        return $ErrorRecord
    }
}

# 使用示例
try {
    # 故意触发错误
    1/0
}
catch {
    # 记录错误
    Write-ErrorLog -ErrorRecord $_
    # 输出友好的错误消息
    Write-Host "发生计算错误，详情已记录到日志文件" -ForegroundColor Red
}

使用trap语句进行错误处理

trap语句是另一种捕获和处理错误的机制，特别适用于需要统一处理整个脚本中错误的情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
# 在脚本开始处设置trap
trap {
    Write-Host "捕获到错误: $($_.Exception.Message)" -ForegroundColor Red
    # 继续执行（如果可能）
    continue
    
    # 或者终止当前执行范围并移至调用者
    # break
}

# 现在脚本中的任何未经处理的错误都会被trap捕获
Get-Process -Name "NonExistentProcess"
Write-Host "这行仍会执行，因为我们在trap中使用了continue"

不同作用域的trap

您可以在不同的作用域中设置多个trap来处理不同类型的错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 默认trap（捕获所有错误）
trap {
    Write-Host "默认trap: $($_.Exception.Message)" -ForegroundColor Red
    continue
}

# 特定异常类型的trap
trap [System.DivideByZeroException] {
    Write-Host "除零错误trap: $($_.Exception.Message)" -ForegroundColor Yellow
    continue
}

# 特定命令产生的错误
trap [System.Management.Automation.CommandNotFoundException] {
    Write-Host "命令未找到trap: $($_.Exception.Message)" -ForegroundColor Cyan
    continue
}

# 测试不同类型的错误
1/0  # 触发除零错误
Get-NonExistentCommand  # 触发命令未找到错误
[System.IO.File]::ReadAllText("C:\NonExistentFile.txt")  # 触发文件未找到错误

创建高级错误处理函数

下面是一个更全面的错误处理函数，它结合了记录、通知和重试功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
function Invoke-WithErrorHandling {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [scriptblock]$ScriptBlock,
        
        [Parameter()]
        [string]$ErrorMessage = "执行脚本块时发生错误",
        
        [Parameter()]
        [string]$LogPath,
        
        [Parameter()]
        [switch]$SuppressOutput,
        
        [Parameter()]
        [int]$RetryCount = 0,
        
        [Parameter()]
        [int]$RetryDelaySeconds = 5,
        
        [Parameter()]
        [scriptblock]$OnErrorAction,
        
        [Parameter()]
        [scriptblock]$FinallyAction
    )
    
    $attempt = 0
    $maxAttempts = $RetryCount + 1  # 初始尝试 + 重试次数
    $success = $false
    $result = $null
    
    do {
        $attempt++
        try {
            Write-Verbose "执行脚本块 (尝试 $attempt/$maxAttempts)"
            
            # 执行脚本块
            $result = & $ScriptBlock
            $success = $true
            
            # 成功完成，退出循环
            break
        }
        catch {
            $currentError = $_
            
            # 构建详细错误信息
            $detailedError = @{
                Message = $currentError.Exception.Message
                Type = $currentError.Exception.GetType().FullName
                ScriptStackTrace = $currentError.ScriptStackTrace
                PositionMessage = $currentError.InvocationInfo.PositionMessage
                Line = $currentError.InvocationInfo.Line.Trim()
                Time = Get-Date
                Attempt = $attempt
            }
            
            # 记录错误
            if ($LogPath) {
                $logEntry = "[$($detailedError.Time.ToString('yyyy-MM-dd HH:mm:ss'))] 尝试 $($detailedError.Attempt)/$maxAttempts`n"
                $logEntry += "错误: $($detailedError.Message)`n"
                $logEntry += "类型: $($detailedError.Type)`n"
                $logEntry += "位置: $($detailedError.PositionMessage)`n"
                $logEntry += "堆栈跟踪: $($detailedError.ScriptStackTrace)`n"
                $logEntry += "====================`n"
                
                # 确保日志目录存在
                $logDir = Split-Path -Path $LogPath -Parent
                if (-not (Test-Path -Path $logDir)) {
                    New-Item -Path $logDir -ItemType Directory -Force | Out-Null
                }
                
                Add-Content -Path $LogPath -Value $logEntry
            }
            
            # 执行自定义错误处理动作
            if ($OnErrorAction) {
                & $OnErrorAction -ErrorInfo $detailedError
            }
            
            # 检查是否需要重试
            if ($attempt -lt $maxAttempts) {
                Write-Verbose "将在 $RetryDelaySeconds 秒后重试..."
                Start-Sleep -Seconds $RetryDelaySeconds
            }
            else {
                # 已达到最大尝试次数，重新抛出错误
                if (-not $SuppressOutput) {
                    Write-Error "$ErrorMessage`n$($detailedError.Message)"
                }
            }
        }
        finally {
            # 执行finally代码块
            if ($FinallyAction) {
                & $FinallyAction
            }
        }
    } while ($attempt -lt $maxAttempts)
    
    if ($success) {
        return $result
    }
}

# 使用示例
$result = Invoke-WithErrorHandling -ScriptBlock {
    # 模拟一个可能失败的操作
    if ((Get-Random -Minimum 1 -Maximum 4) -eq 1) {
        # 操作成功
        return "操作成功"
    }
    else {
        # 操作失败
        throw "随机故障发生"
    }
} -ErrorMessage "执行关键操作时失败" -RetryCount 3 -RetryDelaySeconds 2 -LogPath "C:\Logs\Retry.log" -Verbose -OnErrorAction {
    param($ErrorInfo)
    Write-Host "发生错误，尝试 $($ErrorInfo.Attempt)，错误消息: $($ErrorInfo.Message)" -ForegroundColor Yellow
}

if ($result) {
    Write-Host "最终结果: $result" -ForegroundColor Green
}

在函数中处理管道输入错误

当编写接受管道输入的函数时，错误处理需要特别注意：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
function Process-Items {
    [CmdletBinding()]
    param(
        [Parameter(ValueFromPipeline = $true, Mandatory = $true)]
        [object]$InputObject
    )
    
    begin {
        Write-Verbose "开始处理项目..."
        $errorCount = 0
        $successCount = 0
    }
    
    process {
        try {
            # 处理每个项目
            Write-Verbose "正在处理: $InputObject"
            
            # 模拟处理
            if ($InputObject -eq "bad") {
                throw "发现坏项目!"
            }
            
            # 处理成功
            $successCount++
            Write-Host "成功处理: $InputObject" -ForegroundColor Green
        }
        catch {
            $errorCount++
            Write-Host "处理项目 '$InputObject' 时出错: $($_.Exception.Message)" -ForegroundColor Red
            
            # 可以选择如何处理单个项目的错误:
            # 1. 继续处理下一个项目 (如本例)
            # 2. 通过 throw 停止所有处理
            # 3. 将错误写入错误流但继续处理
            #    $PSCmdlet.WriteError($_)
        }
    }
    
    end {
        Write-Verbose "处理完成。成功: $successCount, 失败: $errorCount"
        
        # 返回摘要对象
        [PSCustomObject]@{
            SuccessCount = $successCount
            ErrorCount = $errorCount
            TotalCount = $successCount + $errorCount
        }
    }
}

# 使用示例
"item1", "bad", "item3" | Process-Items -Verbose

错误过滤器和自定义错误类

您可以创建自定义错误类型和错误过滤器来更好地组织错误处理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# 定义自定义错误类
class CustomValidationError : System.Exception {
    [string]$Reason
    [object]$Value
    
    CustomValidationError([string]$message, [string]$reason, [object]$value) : base($message) {
        $this.Reason = $reason
        $this.Value = $value
    }
}

# 验证函数
function Test-PositiveNumber {
    param(
        [Parameter(Mandatory = $true)]
        [object]$Value
    )
    
    if (-not [double]::TryParse($Value, [ref]$null)) {
        throw [CustomValidationError]::new(
            "值 '$Value' 不是有效的数字",
            "InvalidFormat",
            $Value
        )
    }
    
    if ([double]$Value -le 0) {
        throw [CustomValidationError]::new(
            "值 '$Value' 不是正数",
            "NotPositive",
            $Value
        )
    }
    
    return $true
}

# 使用示例
try {
    $number = "-5"
    Test-PositiveNumber -Value $number
}
catch [CustomValidationError] {
    # 处理自定义验证错误
    $error = $_
    Write-Host "验证错误: $($error.Exception.Message)" -ForegroundColor Red
    Write-Host "原因: $($error.Exception.Reason)" -ForegroundColor Yellow
    Write-Host "提供的值: $($error.Exception.Value)" -ForegroundColor Yellow
}
catch {
    # 处理其他错误
    Write-Host "其他错误: $($_.Exception.Message)" -ForegroundColor Red
}

创建一个完整的错误处理框架

最后，让我们创建一个全面的错误处理框架，可以在多个脚本中重用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
# ErrorHandling.psm1
function Initialize-ErrorHandling {
    [CmdletBinding()]
    param(
        [Parameter()]
        [string]$LogPath = "$env:TEMP\PowerShell_Errors.log",
        
        [Parameter()]
        [ValidateSet('Continue', 'Stop', 'SilentlyContinue', 'Inquire', 'Ignore')]
        [string]$DefaultAction = 'Continue',
        
        [Parameter()]
        [switch]$EnableGlobalErrorLogging,
        
        [Parameter()]
        [switch]$EnableGlobalErrorTrapping,
        
        [Parameter()]
        [scriptblock]$GlobalErrorAction
    )
    
    # 设置默认错误操作
    $script:OriginalErrorActionPreference = $ErrorActionPreference
    $ErrorActionPreference = $DefaultAction
    
    # 确保日志目录存在
    if (-not [string]::IsNullOrWhiteSpace($LogPath)) {
        $logDir = Split-Path -Path $LogPath -Parent
        if (-not (Test-Path -Path $logDir)) {
            New-Item -Path $logDir -ItemType Directory -Force | Out-Null
        }
        $script:ErrorLogPath = $LogPath
    }
    
    # 设置全局错误日志记录
    if ($EnableGlobalErrorLogging) {
        # 覆盖$Error.Clear()方法以记录错误
        $ExecutionContext.SessionState.PSVariable.Set('ErrorClearOriginal', ${function:Clear-Error})
        
        function global:Clear-Error {
            $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
            foreach ($err in $global:Error) {
                $errorEntry = "[$timestamp] ERROR: $($err.Exception.Message)`nCATEGORY: $($err.CategoryInfo.Category)`nFULL: $($err | Out-String)"
                Add-Content -Path $script:ErrorLogPath -Value $errorEntry
            }
            & $function:ErrorClearOriginal
        }
    }
    
    # 设置全局错误捕获
    if ($EnableGlobalErrorTrapping) {
        trap {
            # 记录错误
            $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
            $errorEntry = @"
[$timestamp] TRAPPED ERROR
MESSAGE: $($_.Exception.Message)
TYPE: $($_.Exception.GetType().FullName)
SCRIPT: $($_.InvocationInfo.ScriptName)
LINE NUMBER: $($_.InvocationInfo.ScriptLineNumber)
LINE: $($_.InvocationInfo.Line.Trim())
POSITION: $($_.InvocationInfo.PositionMessage)
STACK TRACE:
$($_.ScriptStackTrace)
====================
"@
            Add-Content -Path $script:ErrorLogPath -Value $errorEntry
            
            # 执行自定义错误处理
            if ($GlobalErrorAction) {
                & $GlobalErrorAction -ErrorRecord $_
            }
            
            # 继续执行
            continue
        }
    }
    
    Write-Verbose "已初始化错误处理框架 (日志路径: $script:ErrorLogPath)"
}

function Reset-ErrorHandling {
    [CmdletBinding()]
    param()
    
    # 恢复原始错误操作首选项
    if ($script:OriginalErrorActionPreference) {
        $ErrorActionPreference = $script:OriginalErrorActionPreference
    }
    
    # 移除全局trap（不可能直接实现，需要重新启动会话）
    
    Write-Verbose "已重置错误处理配置"
}

function Write-DetailedError {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true, Position = 0)]
        [System.Management.Automation.ErrorRecord]$ErrorRecord,
        
        [Parameter()]
        [string]$LogPath = $script:ErrorLogPath,
        
        [Parameter()]
        [switch]$PassThru,
        
        [Parameter()]
        [ValidateSet('Verbose', 'Warning', 'Error', 'Host', 'None')]
        [string]$OutputType = 'Host'
    )
    
    # 格式化详细错误信息
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $formattedError = @"
[$timestamp] ERROR DETAILS
MESSAGE: $($ErrorRecord.Exception.Message)
TYPE: $($ErrorRecord.Exception.GetType().FullName)
SCRIPT: $($ErrorRecord.InvocationInfo.ScriptName)
LINE NUMBER: $($ErrorRecord.InvocationInfo.ScriptLineNumber)
LINE: $($ErrorRecord.InvocationInfo.Line.Trim())
POSITION: $($ErrorRecord.InvocationInfo.PositionMessage)
STACK TRACE:
$($ErrorRecord.ScriptStackTrace)
CATEGORY: $($ErrorRecord.CategoryInfo.Category)
REASON: $($ErrorRecord.CategoryInfo.Reason)
TARGET: $($ErrorRecord.CategoryInfo.TargetName)
FULL ERROR:
$($ErrorRecord | Out-String)
====================
"@
    
    # 记录到文件
    if (-not [string]::IsNullOrWhiteSpace($LogPath)) {
        Add-Content -Path $LogPath -Value $formattedError
    }
    
    # 输出错误
    switch ($OutputType) {
        'Verbose' { Write-Verbose $formattedError }
        'Warning' { Write-Warning $ErrorRecord.Exception.Message }
        'Error' { Write-Error $ErrorRecord.Exception.Message }
        'Host' { 
            Write-Host "ERROR: $($ErrorRecord.Exception.Message)" -ForegroundColor Red
            Write-Host "DETAILS: Type=$($ErrorRecord.Exception.GetType().Name), Script=$($ErrorRecord.InvocationInfo.ScriptName)" -ForegroundColor DarkRed
        }
        'None' { }
    }
    
    # 返回错误
    if ($PassThru) {
        return $ErrorRecord
    }
}

function Invoke-WithRetry {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [scriptblock]$ScriptBlock,
        
        [Parameter()]
        [int]$RetryCount = 3,
        
        [Parameter()]
        [int]$RetryIntervalSeconds = 5,
        
        [Parameter()]
        [scriptblock]$RetryCondition = { $true },
        
        [Parameter()]
        [string]$LogPath = $script:ErrorLogPath,
        
        [Parameter()]
        [scriptblock]$OnRetry
    )
    
    $attempt = 0
    $maxAttempts = $RetryCount + 1  # 初始尝试 + 重试次数
    
    do {
        $attempt++
        $lastError = $null
        
        try {
            Write-Verbose "执行代码块 (尝试 $attempt/$maxAttempts)"
            # 执行脚本块并返回结果
            return & $ScriptBlock
        }
        catch {
            $lastError = $_
            
            # 记录错误
            $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
            $retryLog = @"
[$timestamp] RETRY ATTEMPT $attempt/$maxAttempts
ERROR: $($lastError.Exception.Message)
TYPE: $($lastError.Exception.GetType().FullName)
====================
"@
            if (-not [string]::IsNullOrWhiteSpace($LogPath)) {
                Add-Content -Path $LogPath -Value $retryLog
            }
            
            # 执行OnRetry动作
            if ($OnRetry) {
                & $OnRetry -ErrorRecord $lastError -Attempt $attempt -MaxAttempts $maxAttempts
            }
            
            # 检查是否满足重试条件
            $shouldRetry = & $RetryCondition -ErrorRecord $lastError
            
            if ($shouldRetry -and $attempt -lt $maxAttempts) {
                Write-Verbose "在 $RetryIntervalSeconds 秒后重试..."
                Start-Sleep -Seconds $RetryIntervalSeconds
            }
            else {
                # 已达到最大重试次数或不满足重试条件
                throw $lastError
            }
        }
    } while ($attempt -lt $maxAttempts)
}

# 导出模块函数
Export-ModuleMember -Function Initialize-ErrorHandling, Reset-ErrorHandling, Write-DetailedError, Invoke-WithRetry

使用错误处理框架的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 导入错误处理模块
Import-Module ErrorHandling.psm1

# 初始化错误处理
Initialize-ErrorHandling -LogPath "C:\Logs\MyScript.log" -DefaultAction "Stop" -EnableGlobalErrorLogging -Verbose

try {
    # 使用重试机制执行不稳定操作
    $result = Invoke-WithRetry -ScriptBlock {
        # 模拟不稳定操作
        if ((Get-Random -Minimum 1 -Maximum 5) -lt 3) {
            throw "临时错误，可重试"
        }
        return "操作成功"
    } -RetryCount 5 -RetryIntervalSeconds 2 -OnRetry {
        param($ErrorRecord, $Attempt, $MaxAttempts)
        Write-Host "重试 $Attempt/$MaxAttempts..." -ForegroundColor Yellow
    } -Verbose
    
    Write-Host "最终结果: $result" -ForegroundColor Green
}
catch {
    # 详细记录错误
    Write-DetailedError -ErrorRecord $_ -OutputType "Host"
    
    # 执行清理操作
    Write-Host "执行错误后清理..." -ForegroundColor Cyan
}
finally {
    # 重置错误处理设置
    Reset-ErrorHandling
}

最佳实践总结

  1. 预见错误：识别脚本中可能发生错误的区域，并相应地进行处理。
  2. 使用try/catch/finally：对于可能失败的关键操作，始终使用try/catch块。
  3. 使用-ErrorAction参数：在单个命令级别控制错误行为。
  4. 记录错误：将错误详细信息记录到日志文件，以便后续分析。
  5. 实现重试逻辑：对于网络或其他间歇性操作，实现自动重试。
  6. 提供有意义的错误消息：确保错误消息清晰、具有描述性，并包含足够的上下文信息。
  7. 使用自定义错误类型：对于复杂应用程序，考虑创建自定义错误类型。
  8. 测试错误处理：专门测试错误路径，确保它们按预期工作。

通过实施这些高级错误处理技术，您的PowerShell脚本将更加健壮，更易于调试和维护。良好的错误处理不仅能提高脚本质量，还能降低运营风险，特别是在自动化关键业务流程时。

发表更新powershell / tip5 分钟读完 (大约728个字)

PowerShell 技能连载 - 文件系统操作技巧

在 PowerShell 中处理文件系统操作是一项基础但重要的任务。本文将介绍一些实用的文件系统操作技巧。

首先，让我们看看文件系统的基本操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 创建目录结构
$basePath = "C:\Projects\MyApp"
$directories = @(
    "src",
    "src\components",
    "src\utils",
    "tests",
    "docs"
)

foreach ($dir in $directories) {
    $path = Join-Path $basePath $dir
    New-Item -ItemType Directory -Path $path -Force
    Write-Host "创建目录：$path"
}

文件复制和移动：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 批量复制文件
$sourceDir = "C:\SourceFiles"
$targetDir = "D:\Backup"
$filePattern = "*.docx"

# 获取文件列表
$files = Get-ChildItem -Path $sourceDir -Filter $filePattern -Recurse

foreach ($file in $files) {
    # 保持目录结构
    $relativePath = $file.FullName.Substring($sourceDir.Length)
    $targetPath = Join-Path $targetDir $relativePath
    
    # 创建目标目录
    $targetDirPath = Split-Path -Parent $targetPath
    New-Item -ItemType Directory -Path $targetDirPath -Force
    
    # 复制文件
    Copy-Item -Path $file.FullName -Destination $targetPath
    Write-Host "已复制：$($file.Name) -> $targetPath"
}

文件内容处理：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 批量处理文件内容
$sourceFiles = Get-ChildItem -Path "C:\Logs" -Filter "*.log"

foreach ($file in $sourceFiles) {
    # 读取文件内容
    $content = Get-Content -Path $file.FullName -Raw
    
    # 处理内容（示例：替换特定文本）
    $newContent = $content -replace "ERROR", "错误"
    $newContent = $newContent -replace "WARNING", "警告"
    
    # 保存处理后的内容
    $newPath = Join-Path $file.Directory.FullName "processed_$($file.Name)"
    $newContent | Set-Content -Path $newPath -Encoding UTF8
}

文件系统监控：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 创建文件系统监控函数
function Watch-FileSystem {
    param(
        [string]$Path,
        [string]$Filter = "*.*",
        [int]$Duration = 300
    )
    
    $watcher = New-Object System.IO.FileSystemWatcher
    $watcher.Path = $Path
    $watcher.Filter = $Filter
    $watcher.IncludeSubdirectories = $true
    $watcher.EnableRaisingEvents = $true
    
    Write-Host "开始监控目录：$Path"
    Write-Host "监控时长：$Duration 秒"
    
    # 定义事件处理
    $action = {
        $event = $Event.SourceEventArgs
        $changeType = $event.ChangeType
        $name = $event.Name
        $path = $event.FullPath
        
        Write-Host "`n检测到变化："
        Write-Host "类型：$changeType"
        Write-Host "文件：$name"
        Write-Host "路径：$path"
    }
    
    # 注册事件
    Register-ObjectEvent -InputObject $watcher -EventName Created -Action $action
    Register-ObjectEvent -InputObject $watcher -EventName Changed -Action $action
    Register-ObjectEvent -InputObject $watcher -EventName Deleted -Action $action
    Register-ObjectEvent -InputObject $watcher -EventName Renamed -Action $action
    
    # 等待指定时间
    Start-Sleep -Seconds $Duration
    
    # 清理
    $watcher.EnableRaisingEvents = $false
    $watcher.Dispose()
}

一些实用的文件系统操作技巧：

  1. 文件压缩和解压：
1
2
3
4
5
6
7
8
9
10
# 压缩文件
$sourcePath = "C:\Data"
$zipPath = "C:\Archive\data.zip"

# 创建压缩文件
Compress-Archive -Path "$sourcePath\*" -DestinationPath $zipPath -Force

# 解压文件
$extractPath = "C:\Extracted"
Expand-Archive -Path $zipPath -DestinationPath $extractPath -Force
  1. 文件权限管理：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 设置文件权限
$filePath = "C:\Sensitive\data.txt"
$acl = Get-Acl -Path $filePath

# 添加新的访问规则
$rule = New-Object System.Security.AccessControl.FileSystemAccessRule(
    "Domain\Users",
    "Read",
    "Allow"
)
$acl.SetAccessRule($rule)

# 应用新的权限
Set-Acl -Path $filePath -AclObject $acl
  1. 文件系统清理：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 清理临时文件
$tempPaths = @(
    $env:TEMP,
    "C:\Windows\Temp",
    "C:\Users\$env:USERNAME\AppData\Local\Temp"
)

foreach ($path in $tempPaths) {
    Write-Host "`n清理目录：$path"
    $files = Get-ChildItem -Path $path -Recurse -File | 
        Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-7) }
    
    foreach ($file in $files) {
        try {
            Remove-Item -Path $file.FullName -Force
            Write-Host "已删除：$($file.Name)"
        }
        catch {
            Write-Host "删除失败：$($file.Name) - $_"
        }
    }
}

这些技巧将帮助您更有效地处理文件系统操作。记住，在进行文件系统操作时，始终要注意数据安全性和权限管理。同时，建议在执行批量操作前先进行备份。

发表更新powershell / tip3 分钟读完 (大约482个字)

PowerShell 技能连载 - 视频处理技巧

在 PowerShell 中处理视频文件可能不是最常见的任务，但在某些场景下非常有用。本文将介绍一些实用的视频处理技巧。

首先，让我们看看基本的视频操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 创建视频信息获取函数
function Get-VideoInfo {
    param(
        [string]$VideoPath
    )
    
    try {
        # 使用 FFmpeg 获取视频信息
        $ffmpeg = "C:\ffmpeg\bin\ffmpeg.exe"
        $info = & $ffmpeg -i $VideoPath 2>&1
        
        $duration = [regex]::Match($info, "Duration: (\d{2}):(\d{2}):(\d{2})")
        $size = (Get-Item $VideoPath).Length
        
        return [PSCustomObject]@{
            FileName = Split-Path $VideoPath -Leaf
            Duration = [TimeSpan]::new(
                [int]$duration.Groups[1].Value,
                [int]$duration.Groups[2].Value,
                [int]$duration.Groups[3].Value
            )
            FileSize = $size
            Info = $info
        }
    }
    catch {
        Write-Host "获取视频信息失败：$_"
    }
}

视频格式转换：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 创建视频格式转换函数
function Convert-VideoFormat {
    param(
        [string]$InputPath,
        [string]$OutputPath,
        [ValidateSet("mp4", "avi", "mkv", "mov")]
        [string]$TargetFormat
    )
    
    try {
        $ffmpeg = "C:\ffmpeg\bin\ffmpeg.exe"
        
        switch ($TargetFormat) {
            "mp4" {
                & $ffmpeg -i $InputPath -c:v libx264 -c:a aac -preset medium $OutputPath
            }
            "avi" {
                & $ffmpeg -i $InputPath -c:v libxvid -c:a libmp3lame $OutputPath
            }
            "mkv" {
                & $ffmpeg -i $InputPath -c copy $OutputPath
            }
            "mov" {
                & $ffmpeg -i $InputPath -c:v libx264 -c:a aac -f mov $OutputPath
            }
        }
        
        Write-Host "视频转换完成：$OutputPath"
    }
    catch {
        Write-Host "转换失败：$_"
    }
}

视频剪辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 创建视频剪辑函数
function Split-Video {
    param(
        [string]$InputPath,
        [string]$OutputPath,
        [TimeSpan]$StartTime,
        [TimeSpan]$Duration
    )
    
    try {
        $ffmpeg = "C:\ffmpeg\bin\ffmpeg.exe"
        $start = $StartTime.ToString("hh\:mm\:ss")
        $duration = $Duration.ToString("hh\:mm\:ss")
        
        & $ffmpeg -i $InputPath -ss $start -t $duration -c copy $OutputPath
        Write-Host "视频剪辑完成：$OutputPath"
    }
    catch {
        Write-Host "剪辑失败：$_"
    }
}

视频压缩：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 创建视频压缩函数
function Compress-Video {
    param(
        [string]$InputPath,
        [string]$OutputPath,
        [ValidateSet("high", "medium", "low")]
        [string]$Quality = "medium"
    )
    
    try {
        $ffmpeg = "C:\ffmpeg\bin\ffmpeg.exe"
        
        $crf = switch ($Quality) {
            "high" { "23" }
            "medium" { "28" }
            "low" { "33" }
        }
        
        & $ffmpeg -i $InputPath -c:v libx264 -crf $crf -preset medium -c:a aac -b:a 128k $OutputPath
        Write-Host "视频压缩完成：$OutputPath"
    }
    catch {
        Write-Host "压缩失败：$_"
    }
}

这些技巧将帮助您更有效地处理视频文件。记住，在处理视频时，始终要注意文件大小和编码质量。同时，建议在处理大型视频文件时使用流式处理方式，以提高性能。

发表更新powershell / basic1 分钟读完 (大约128个字)

PowerShell数组与集合操作精要

基础操作演示

1
2
3
4
5
6
7
8
# 数组创建与扩展
$numbers = 1..5
$numbers += 6
$numbers.Where{ $_ -gt 3 }

# 哈希表快速构建
$profile = @{Name='张三'; Role='开发者'}
$profile.Keys | ForEach-Object { "$_ : $($profile[$_])" }

高效集合处理

1
2
3
4
5
6
7
# 使用ArrayList提升性能
$list = [System.Collections.ArrayList]::new()
1..10000 | ForEach-Object { $null = $list.Add($_) }

# 泛型列表应用
$genericList = [System.Collections.Generic.List[int]]::new()
$genericList.AddRange((1..100))

注意事项

  1. 避免使用+=追加大型数组
  2. 优先使用管道处理大数据集
  3. 明确集合类型提升处理效率
  4. 类型强转时的空值处理策略
发表更新powershell / security1 分钟读完 (大约197个字)

PowerShell 技能连载 - 供应链安全漏洞扫描

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
function Invoke-SupplyChainScan {
    param(
        [Parameter(Mandatory=$true)]
        [string]$ImageName,
        [string]$OutputFormat = 'table',
        [string]$SeverityLevel = 'HIGH,CRITICAL'
    )

    # 安装Trivy漏洞扫描器
    if (-not (Get-Command trivy -ErrorAction SilentlyContinue)) {
        winget install aquasecurity.trivy
    }

    try {
        # 执行容器镜像扫描
        $result = trivy image --format $OutputFormat --severity $SeverityLevel $ImageName
        
        # 生成HTML报告
        $htmlReport = "$env:TEMP\scan_report_$(Get-Date -Format yyyyMMddHHmmss).html"
        trivy image --format template --template "@contrib/html.tpl" -o $htmlReport $ImageName
        
        [PSCustomObject]@{
            ScanTarget = $ImageName
            VulnerabilitiesFound = $result.Count
            CriticalCount = ($result | Where-Object { $_ -match 'CRITICAL' }).Count
            HighCount = ($result | Where-Object { $_ -match 'HIGH' }).Count
            HTMLReportPath = $htmlReport
        }
    }
    catch {
        Write-Error "漏洞扫描失败：$_"
    }
}

核心功能：

  1. 集成Trivy进行容器镜像漏洞扫描
  2. 支持多种输出格式(table/json/html)
  3. 自动生成带严重等级分类的报告
  4. 包含依赖组件版本检查

应用场景：

  • CI/CD流水线安全门禁
  • 第三方组件入仓检查
  • 生产环境镜像定期审计
发表更新powershell / tip7 分钟读完 (大约1063个字)

PowerShell 技能连载 - 金融行业集成

在金融行业，PowerShell可以帮助我们更好地管理交易系统、风险控制和合规性。本文将介绍如何使用PowerShell构建一个金融行业管理系统，包括交易监控、风险管理和合规性检查等功能。

交易监控

首先，让我们创建一个用于监控金融交易的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
function Monitor-FinancialTransactions {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$MonitorID,
        
        [Parameter()]
        [string[]]$TransactionTypes,
        
        [Parameter()]
        [ValidateSet("RealTime", "Batch", "Analysis")]
        [string]$MonitorMode = "RealTime",
        
        [Parameter()]
        [hashtable]$MonitorConfig,
        
        [Parameter()]
        [string]$LogPath
    )
    
    try {
        $monitor = [PSCustomObject]@{
            MonitorID = $MonitorID
            StartTime = Get-Date
            TransactionStatus = @{}
            Metrics = @{}
            Alerts = @()
        }
        
        # 获取监控配置
        $config = Get-MonitorConfig -MonitorID $MonitorID
        
        # 监控交易
        foreach ($type in $TransactionTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Metrics = @{}
                Alerts = @()
            }
            
            # 应用监控配置
            $typeConfig = Apply-MonitorConfig `
                -Config $config `
                -Type $type `
                -Mode $MonitorMode `
                -Settings $MonitorConfig
            
            $status.Config = $typeConfig
            
            # 收集交易指标
            $metrics = Collect-TransactionMetrics `
                -Type $type `
                -Config $typeConfig
            
            $status.Metrics = $metrics
            $monitor.Metrics[$type] = $metrics
            
            # 检查交易告警
            $alerts = Check-TransactionAlerts `
                -Metrics $metrics `
                -Config $typeConfig
            
            $status.Alerts = $alerts
            $monitor.Alerts += $alerts
            
            # 更新交易状态
            if ($alerts.Count -gt 0) {
                $status.Status = "Warning"
            }
            else {
                $status.Status = "Normal"
            }
            
            $monitor.TransactionStatus[$type] = $status
        }
        
        # 记录监控日志
        if ($LogPath) {
            $monitor | ConvertTo-Json -Depth 10 | Out-File -FilePath $LogPath
        }
        
        # 更新监控器状态
        $monitor.EndTime = Get-Date
        
        return $monitor
    }
    catch {
        Write-Error "交易监控失败：$_"
        return $null
    }
}

风险管理

接下来，创建一个用于管理金融风险的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
function Manage-FinancialRisk {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$RiskID,
        
        [Parameter()]
        [string[]]$RiskTypes,
        
        [Parameter()]
        [ValidateSet("Assess", "Mitigate", "Monitor")]
        [string]$OperationMode = "Assess",
        
        [Parameter()]
        [hashtable]$RiskConfig,
        
        [Parameter()]
        [string]$ReportPath
    )
    
    try {
        $manager = [PSCustomObject]@{
            RiskID = $RiskID
            StartTime = Get-Date
            RiskStatus = @{}
            Operations = @{}
            Issues = @()
        }
        
        # 获取风险配置
        $config = Get-RiskConfig -RiskID $RiskID
        
        # 管理风险
        foreach ($type in $RiskTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Operations = @{}
                Issues = @()
            }
            
            # 应用风险配置
            $typeConfig = Apply-RiskConfig `
                -Config $config `
                -Type $type `
                -Mode $OperationMode `
                -Settings $RiskConfig
            
            $status.Config = $typeConfig
            
            # 执行风险操作
            $operations = Execute-RiskOperations `
                -Type $type `
                -Config $typeConfig
            
            $status.Operations = $operations
            $manager.Operations[$type] = $operations
            
            # 检查风险问题
            $issues = Check-RiskIssues `
                -Operations $operations `
                -Config $typeConfig
            
            $status.Issues = $issues
            $manager.Issues += $issues
            
            # 更新风险状态
            if ($issues.Count -gt 0) {
                $status.Status = "High"
            }
            else {
                $status.Status = "Low"
            }
            
            $manager.RiskStatus[$type] = $status
        }
        
        # 生成报告
        if ($ReportPath) {
            $report = Generate-RiskReport `
                -Manager $manager `
                -Config $config
            
            $report | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath
        }
        
        # 更新管理器状态
        $manager.EndTime = Get-Date
        
        return $manager
    }
    catch {
        Write-Error "风险管理失败：$_"
        return $null
    }
}

合规性检查

最后，创建一个用于检查金融合规性的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
function Check-FinancialCompliance {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$ComplianceID,
        
        [Parameter()]
        [string[]]$ComplianceTypes,
        
        [Parameter()]
        [ValidateSet("Audit", "Enforce", "Report")]
        [string]$OperationMode = "Audit",
        
        [Parameter()]
        [hashtable]$ComplianceConfig,
        
        [Parameter()]
        [string]$ReportPath
    )
    
    try {
        $checker = [PSCustomObject]@{
            ComplianceID = $ComplianceID
            StartTime = Get-Date
            ComplianceStatus = @{}
            Operations = @{}
            Issues = @()
        }
        
        # 获取合规性配置
        $config = Get-ComplianceConfig -ComplianceID $ComplianceID
        
        # 检查合规性
        foreach ($type in $ComplianceTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Operations = @{}
                Issues = @()
            }
            
            # 应用合规性配置
            $typeConfig = Apply-ComplianceConfig `
                -Config $config `
                -Type $type `
                -Mode $OperationMode `
                -Settings $ComplianceConfig
            
            $status.Config = $typeConfig
            
            # 执行合规性操作
            $operations = Execute-ComplianceOperations `
                -Type $type `
                -Config $typeConfig
            
            $status.Operations = $operations
            $checker.Operations[$type] = $operations
            
            # 检查合规性问题
            $issues = Check-ComplianceIssues `
                -Operations $operations `
                -Config $typeConfig
            
            $status.Issues = $issues
            $checker.Issues += $issues
            
            # 更新合规性状态
            if ($issues.Count -gt 0) {
                $status.Status = "NonCompliant"
            }
            else {
                $status.Status = "Compliant"
            }
            
            $checker.ComplianceStatus[$type] = $status
        }
        
        # 生成报告
        if ($ReportPath) {
            $report = Generate-ComplianceReport `
                -Checker $checker `
                -Config $config
            
            $report | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath
        }
        
        # 更新检查器状态
        $checker.EndTime = Get-Date
        
        return $checker
    }
    catch {
        Write-Error "合规性检查失败：$_"
        return $null
    }
}

使用示例

以下是如何使用这些函数来管理金融环境的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
# 监控金融交易
$monitor = Monitor-FinancialTransactions -MonitorID "MONITOR001" `
    -TransactionTypes @("Equity", "FixedIncome", "Derivatives") `
    -MonitorMode "RealTime" `
    -MonitorConfig @{
        "Equity" = @{
            "Thresholds" = @{
                "Volume" = @{
                    "Warning" = 1000000
                    "Critical" = 5000000
                }
                "Price" = @{
                    "Warning" = 0.05
                    "Critical" = 0.10
                }
            }
            "Alerts" = @{
                "Volume" = $true
                "Price" = $true
                "Pattern" = $true
            }
        }
        "FixedIncome" = @{
            "Thresholds" = @{
                "Yield" = @{
                    "Warning" = 0.02
                    "Critical" = 0.05
                }
                "Spread" = @{
                    "Warning" = 0.01
                    "Critical" = 0.03
                }
            }
            "Alerts" = @{
                "Yield" = $true
                "Spread" = $true
                "Duration" = $true
            }
        }
        "Derivatives" = @{
            "Thresholds" = @{
                "Delta" = @{
                    "Warning" = 0.5
                    "Critical" = 0.8
                }
                "Gamma" = @{
                    "Warning" = 0.1
                    "Critical" = 0.3
                }
            }
            "Alerts" = @{
                "Delta" = $true
                "Gamma" = $true
                "Theta" = $true
            }
        }
    } `
    -LogPath "C:\Logs\transaction_monitoring.json"

# 管理金融风险
$manager = Manage-FinancialRisk -RiskID "RISK001" `
    -RiskTypes @("Market", "Credit", "Operational") `
    -OperationMode "Assess" `
    -RiskConfig @{
        "Market" = @{
            "Metrics" = @{
                "VaR" = @{
                    "Limit" = 1000000
                    "Period" = "Daily"
                }
                "StressTest" = @{
                    "Scenarios" = @("Normal", "Adverse", "Severe")
                    "Frequency" = "Weekly"
                }
            }
            "Controls" = @{
                "PositionLimits" = $true
                "StopLoss" = $true
                "Hedging" = $true
            }
        }
        "Credit" = @{
            "Metrics" = @{
                "PD" = @{
                    "Threshold" = 0.05
                    "Review" = "Monthly"
                }
                "LGD" = @{
                    "Threshold" = 0.4
                    "Review" = "Monthly"
                }
            }
            "Controls" = @{
                "Collateral" = $true
                "Netting" = $true
                "Rating" = $true
            }
        }
        "Operational" = @{
            "Metrics" = @{
                "Incidents" = @{
                    "Threshold" = 5
                    "Period" = "Monthly"
                }
                "Recovery" = @{
                    "Target" = "4Hours"
                    "Testing" = "Quarterly"
                }
            }
            "Controls" = @{
                "Backup" = $true
                "DR" = $true
                "BCP" = $true
            }
        }
    } `
    -ReportPath "C:\Reports\risk_management.json"

# 检查金融合规性
$checker = Check-FinancialCompliance -ComplianceID "COMPLIANCE001" `
    -ComplianceTypes @("Regulatory", "Internal", "Industry") `
    -OperationMode "Audit" `
    -ComplianceConfig @{
        "Regulatory" = @{
            "Rules" = @{
                "Basel" = @{
                    "Capital" = $true
                    "Liquidity" = $true
                    "Reporting" = $true
                }
                "DoddFrank" = @{
                    "Clearing" = $true
                    "Reporting" = $true
                    "Trading" = $true
                }
            }
            "Reporting" = @{
                "Frequency" = "Daily"
                "Format" = "Regulatory"
                "Validation" = $true
            }
        }
        "Internal" = @{
            "Policies" = @{
                "Trading" = @{
                    "Limits" = $true
                    "Approvals" = $true
                    "Monitoring" = $true
                }
                "Risk" = @{
                    "Assessment" = $true
                    "Mitigation" = $true
                    "Review" = $true
                }
            }
            "Controls" = @{
                "Access" = $true
                "Segregation" = $true
                "Audit" = $true
            }
        }
        "Industry" = @{
            "Standards" = @{
                "ISO27001" = @{
                    "Security" = $true
                    "Privacy" = $true
                    "Compliance" = $true
                }
                "PCI" = @{
                    "Data" = $true
                    "Security" = $true
                    "Monitoring" = $true
                }
            }
            "Certification" = @{
                "Required" = $true
                "Renewal" = "Annual"
                "Audit" = $true
            }
        }
    } `
    -ReportPath "C:\Reports\compliance_check.json"

最佳实践

  1. 实施实时交易监控
  2. 管理金融风险
  3. 确保合规性
  4. 保持详细的审计记录
  5. 定期进行风险评估
  6. 实施访问控制
  7. 建立应急响应机制
  8. 保持系统文档更新
发表更新powershell / tip7 分钟读完 (大约994个字)

PowerShell 技能连载 - 事件管理

在系统管理中，事件管理对于确保系统正常运行和及时响应问题至关重要。本文将介绍如何使用PowerShell构建一个事件管理系统，包括事件收集、分析和响应等功能。

事件收集

首先，让我们创建一个用于管理事件收集的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
function Collect-SystemEvents {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$CollectionID,
        
        [Parameter()]
        [string[]]$EventTypes,
        
        [Parameter()]
        [ValidateSet("RealTime", "Scheduled", "OnDemand")]
        [string]$CollectionMode = "RealTime",
        
        [Parameter()]
        [hashtable]$CollectionConfig,
        
        [Parameter()]
        [string]$LogPath
    )
    
    try {
        $collector = [PSCustomObject]@{
            CollectionID = $CollectionID
            StartTime = Get-Date
            CollectionStatus = @{}
            Events = @{}
            Issues = @()
        }
        
        # 获取收集配置
        $config = Get-CollectionConfig -CollectionID $CollectionID
        
        # 管理收集
        foreach ($type in $EventTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Events = @{}
                Issues = @()
            }
            
            # 应用收集配置
            $typeConfig = Apply-CollectionConfig `
                -Config $config `
                -Type $type `
                -Mode $CollectionMode `
                -Settings $CollectionConfig
            
            $status.Config = $typeConfig
            
            # 收集系统事件
            $events = Collect-EventData `
                -Type $type `
                -Config $typeConfig
            
            $status.Events = $events
            $collector.Events[$type] = $events
            
            # 检查收集问题
            $issues = Check-CollectionIssues `
                -Events $events `
                -Config $typeConfig
            
            $status.Issues = $issues
            $collector.Issues += $issues
            
            # 更新收集状态
            if ($issues.Count -gt 0) {
                $status.Status = "Warning"
            }
            else {
                $status.Status = "Success"
            }
            
            $collector.CollectionStatus[$type] = $status
        }
        
        # 记录收集日志
        if ($LogPath) {
            $collector | ConvertTo-Json -Depth 10 | Out-File -FilePath $LogPath
        }
        
        # 更新收集器状态
        $collector.EndTime = Get-Date
        
        return $collector
    }
    catch {
        Write-Error "事件收集失败：$_"
        return $null
    }
}

事件分析

接下来，创建一个用于管理事件分析的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
function Analyze-SystemEvents {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$AnalysisID,
        
        [Parameter()]
        [string[]]$AnalysisTypes,
        
        [Parameter()]
        [ValidateSet("Pattern", "Anomaly", "Correlation")]
        [string]$AnalysisMode = "Pattern",
        
        [Parameter()]
        [hashtable]$AnalysisConfig,
        
        [Parameter()]
        [string]$ReportPath
    )
    
    try {
        $analyzer = [PSCustomObject]@{
            AnalysisID = $AnalysisID
            StartTime = Get-Date
            AnalysisStatus = @{}
            Analysis = @{}
            Insights = @()
        }
        
        # 获取分析配置
        $config = Get-AnalysisConfig -AnalysisID $AnalysisID
        
        # 管理分析
        foreach ($type in $AnalysisTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Analysis = @{}
                Insights = @()
            }
            
            # 应用分析配置
            $typeConfig = Apply-AnalysisConfig `
                -Config $config `
                -Type $type `
                -Mode $AnalysisMode `
                -Settings $AnalysisConfig
            
            $status.Config = $typeConfig
            
            # 分析系统事件
            $analysis = Analyze-EventPatterns `
                -Type $type `
                -Config $typeConfig
            
            $status.Analysis = $analysis
            $analyzer.Analysis[$type] = $analysis
            
            # 生成分析洞察
            $insights = Generate-AnalysisInsights `
                -Analysis $analysis `
                -Config $typeConfig
            
            $status.Insights = $insights
            $analyzer.Insights += $insights
            
            # 更新分析状态
            if ($insights.Count -gt 0) {
                $status.Status = "Active"
            }
            else {
                $status.Status = "Inactive"
            }
            
            $analyzer.AnalysisStatus[$type] = $status
        }
        
        # 生成报告
        if ($ReportPath) {
            $report = Generate-AnalysisReport `
                -Analyzer $analyzer `
                -Config $config
            
            $report | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath
        }
        
        # 更新分析器状态
        $analyzer.EndTime = Get-Date
        
        return $analyzer
    }
    catch {
        Write-Error "事件分析失败：$_"
        return $null
    }
}

事件响应

最后，创建一个用于管理事件响应的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
function Respond-SystemEvents {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$ResponseID,
        
        [Parameter()]
        [string[]]$ResponseTypes,
        
        [Parameter()]
        [ValidateSet("Automatic", "Manual", "Hybrid")]
        [string]$ResponseMode = "Automatic",
        
        [Parameter()]
        [hashtable]$ResponseConfig,
        
        [Parameter()]
        [string]$ReportPath
    )
    
    try {
        $responder = [PSCustomObject]@{
            ResponseID = $ResponseID
            StartTime = Get-Date
            ResponseStatus = @{}
            Responses = @{}
            Actions = @()
        }
        
        # 获取响应配置
        $config = Get-ResponseConfig -ResponseID $ResponseID
        
        # 管理响应
        foreach ($type in $ResponseTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Responses = @{}
                Actions = @()
            }
            
            # 应用响应配置
            $typeConfig = Apply-ResponseConfig `
                -Config $config `
                -Type $type `
                -Mode $ResponseMode `
                -Settings $ResponseConfig
            
            $status.Config = $typeConfig
            
            # 响应系统事件
            $responses = Respond-EventActions `
                -Type $type `
                -Config $typeConfig
            
            $status.Responses = $responses
            $responder.Responses[$type] = $responses
            
            # 执行响应动作
            $actions = Execute-ResponseActions `
                -Responses $responses `
                -Config $typeConfig
            
            $status.Actions = $actions
            $responder.Actions += $actions
            
            # 更新响应状态
            if ($actions.Count -gt 0) {
                $status.Status = "Active"
            }
            else {
                $status.Status = "Inactive"
            }
            
            $responder.ResponseStatus[$type] = $status
        }
        
        # 生成报告
        if ($ReportPath) {
            $report = Generate-ResponseReport `
                -Responder $responder `
                -Config $config
            
            $report | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath
        }
        
        # 更新响应器状态
        $responder.EndTime = Get-Date
        
        return $responder
    }
    catch {
        Write-Error "事件响应失败：$_"
        return $null
    }
}

使用示例

以下是如何使用这些函数来管理事件的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
# 收集系统事件
$collector = Collect-SystemEvents -CollectionID "COLLECTION001" `
    -EventTypes @("System", "Application", "Security", "Performance") `
    -CollectionMode "RealTime" `
    -CollectionConfig @{
        "System" = @{
            "Sources" = @("EventLog", "Syslog", "SNMP")
            "Levels" = @("Critical", "Error", "Warning", "Info")
            "Filter" = "Level >= Warning"
            "Retention" = 7
        }
        "Application" = @{
            "Sources" = @("LogFile", "Database", "API")
            "Levels" = @("Critical", "Error", "Warning", "Info")
            "Filter" = "Level >= Warning"
            "Retention" = 7
        }
        "Security" = @{
            "Sources" = @("AuditLog", "IDS", "Firewall")
            "Levels" = @("Critical", "Error", "Warning", "Info")
            "Filter" = "Level >= Warning"
            "Retention" = 7
        }
        "Performance" = @{
            "Sources" = @("Metrics", "Counters", "Probes")
            "Levels" = @("Critical", "Error", "Warning", "Info")
            "Filter" = "Level >= Warning"
            "Retention" = 7
        }
    } `
    -LogPath "C:\Logs\event_collection.json"

# 分析系统事件
$analyzer = Analyze-SystemEvents -AnalysisID "ANALYSIS001" `
    -AnalysisTypes @("Pattern", "Anomaly", "Correlation") `
    -AnalysisMode "Pattern" `
    -AnalysisConfig @{
        "Pattern" = @{
            "Methods" = @("Statistical", "MachineLearning", "RuleBased")
            "Threshold" = 0.8
            "Interval" = 60
            "Report" = $true
        }
        "Anomaly" = @{
            "Methods" = @("Statistical", "MachineLearning", "RuleBased")
            "Threshold" = 0.8
            "Interval" = 60
            "Report" = $true
        }
        "Correlation" = @{
            "Methods" = @("Statistical", "MachineLearning", "RuleBased")
            "Threshold" = 0.8
            "Interval" = 60
            "Report" = $true
        }
    } `
    -ReportPath "C:\Reports\event_analysis.json"

# 响应系统事件
$responder = Respond-SystemEvents -ResponseID "RESPONSE001" `
    -ResponseTypes @("System", "Application", "Security", "Performance") `
    -ResponseMode "Automatic" `
    -ResponseConfig @{
        "System" = @{
            "Actions" = @("Restart", "Failover", "Alert")
            "Timeout" = 300
            "Retry" = 3
            "Report" = $true
        }
        "Application" = @{
            "Actions" = @("Restart", "Failover", "Alert")
            "Timeout" = 300
            "Retry" = 3
            "Report" = $true
        }
        "Security" = @{
            "Actions" = @("Block", "Isolate", "Alert")
            "Timeout" = 300
            "Retry" = 3
            "Report" = $true
        }
        "Performance" = @{
            "Actions" = @("Scale", "Optimize", "Alert")
            "Timeout" = 300
            "Retry" = 3
            "Report" = $true
        }
    } `
    -ReportPath "C:\Reports\event_response.json"

最佳实践

  1. 实施事件收集
  2. 分析事件模式
  3. 响应事件问题
  4. 保持详细的事件记录
  5. 定期进行事件审查
  6. 实施响应策略
  7. 建立事件控制
  8. 保持系统文档更新
关注我

链接

PowerShell 技术 QQ 群
PowerShell 技术 QQ 群

最新文章

归档

标签

powershell2360
tip2264
powertip2264
series2264
scripting78
best-practices73
automation66
azure60
security59
devops45
system-management41
tooling39
monitoring39
script38
web31
network31
geek30
text-processing25
cloud22
container21
ai21
windows20
data-format20
identity19
performance16
config-management16
package-management15
database11
testing11
qq10
office10
remoting10
reporting9
linux8
cross-platform8
data-processing8
virtualization5
microsoft4
troubleshooting4
command3
wmi3
cim3
streaming3
storage3
video2
macos2
site-management2
patterns2
inventory2
module2

分类

×