powershellblog.com – Page 18 – Mastering PowerShell: Tips, Tricks, and Best Practices

Advanced Network Diagnostics Tool

08/08/2024/0 Comments/in Program/by Laszlo Bocso

Description:

This PowerShell script creates a simple network diagnostics tool. It allows users to perform basic network troubleshooting tasks such as pinging a host, checking DNS resolution, viewing network adapter information, and performing a traceroute. The script demonstrates working with network-related cmdlets, handling user input, and presenting network information in a readable format.

Full Script:

# Advanced Network Diagnostics Tool

# Function to display the menu
function Show-Menu {
    Clear-Host
    Write-Host "=== Advanced Network Diagnostics Tool ===" -ForegroundColor Cyan
    Write-Host "1.  Ping a host"
    Write-Host "2.  Resolve DNS"
    Write-Host "3.  View network adapter information"
    Write-Host "4.  Perform traceroute"
    Write-Host "5.  View open ports"
    Write-Host "6.  Check internet connectivity"
    Write-Host "7.  View IP configuration"
    Write-Host "8.  Perform a network speed test"
    Write-Host "9.  Flush DNS cache"
    Write-Host "10. View routing table"
    Write-Host "11. Exit"
}

# Function to ping a host
function Ping-Host {
    $host_name = Read-Host "Enter the host name or IP address to ping"
    Write-Host "`nPinging $host_name..." -ForegroundColor Yellow
    $result = Test-Connection -ComputerName $host_name -Count 4 -ErrorAction SilentlyContinue
    if ($result) {
        $result | Format-Table @{Name="Source"; Expression={$_.PSComputerName}}, 
                               @{Name="Destination"; Expression={$_.Address}}, 
                               @{Name="IPV4Address"; Expression={$_.IPV4Address}}, 
                               ResponseTime
    } else {
        Write-Host "Unable to reach $host_name" -ForegroundColor Red
    }
}

# Function to resolve DNS
function Resolve-DNSName {
    $dns_name = Read-Host "Enter the domain name to resolve"
    Write-Host "`nResolving $dns_name..." -ForegroundColor Yellow
    try {
        $result = Resolve-DnsName -Name $dns_name -ErrorAction Stop
        $result | Format-Table Name, IPAddress
    } catch {
        Write-Host "Unable to resolve $dns_name. Error: $($_.Exception.Message)" -ForegroundColor Red
    }
}

# Function to view network adapter information
function View-NetworkAdapters {
    Write-Host "`nNetwork Adapter Information:" -ForegroundColor Yellow
    Get-NetAdapter | Where-Object Status -eq "Up" | Format-Table Name, InterfaceDescription, Status, LinkSpeed
}

# Function to perform traceroute
function Perform-Traceroute {
    $destination = Read-Host "Enter the destination for traceroute"
    Write-Host "`nPerforming traceroute to $destination..." -ForegroundColor Yellow
    Test-NetConnection -ComputerName $destination -TraceRoute | 
        Select-Object -ExpandProperty TraceRoute | 
        ForEach-Object { Write-Host $_ }
}

# Function to view open ports
function View-OpenPorts {
    Write-Host "`nViewing open ports..." -ForegroundColor Yellow
    Get-NetTCPConnection | Where-Object State -eq "Established" | 
        Format-Table LocalAddress, LocalPort, RemoteAddress, RemotePort, State
}

# Function to check internet connectivity
function Check-InternetConnectivity {
    Write-Host "`nChecking internet connectivity..." -ForegroundColor Yellow
    $testResult = Test-NetConnection -ComputerName "www.google.com" -InformationLevel "Detailed"
    if ($testResult.TcpTestSucceeded) {
        Write-Host "Internet is accessible." -ForegroundColor Green
    } else {
        Write-Host "Internet is not accessible." -ForegroundColor Red
    }
    $testResult | Format-List
}

# Function to view IP configuration
function View-IPConfiguration {
    Write-Host "`nIP Configuration:" -ForegroundColor Yellow
    Get-NetIPConfiguration | Format-List InterfaceAlias, IPv4Address, IPv6Address, DNSServer
}

# Function to perform a network speed test
function Perform-SpeedTest {
    Write-Host "`nPerforming network speed test..." -ForegroundColor Yellow
    # Note: This requires the installation of speedtest-cli
    # You can install it using: winget install Ookla.Speedtest.CLI
    try {
        $result = speedtest --format=json --progress=no | ConvertFrom-Json
        Write-Host "Download Speed: $([math]::Round($result.download.bandwidth / 125000, 2)) Mbps"
        Write-Host "Upload Speed: $([math]::Round($result.upload.bandwidth / 125000, 2)) Mbps"
        Write-Host "Ping: $($result.ping.latency) ms"
    } catch {
        Write-Host "Unable to perform speed test. Make sure speedtest-cli is installed." -ForegroundColor Red
    }
}

# Function to flush DNS cache
function Flush-DNSCache {
    Write-Host "`nFlushing DNS cache..." -ForegroundColor Yellow
    Clear-DnsClientCache
    Write-Host "DNS cache flushed successfully." -ForegroundColor Green
}

# Function to view routing table
function View-RoutingTable {
    Write-Host "`nRouting Table:" -ForegroundColor Yellow
    Get-NetRoute | Format-Table DestinationPrefix, NextHop, RouteMetric, ifIndex
}

# Main program loop
do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-11)"

    switch ($choice) {
        "1"  { Ping-Host }
        "2"  { Resolve-DNSName }
        "3"  { View-NetworkAdapters }
        "4"  { Perform-Traceroute }
        "5"  { View-OpenPorts }
        "6"  { Check-InternetConnectivity }
        "7"  { View-IPConfiguration }
        "8"  { Perform-SpeedTest }
        "9"  { Flush-DNSCache }
        "10" { View-RoutingTable }
        "11" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "11") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "11")

This advanced Network Diagnostics Tool includes:

A comprehensive menu with 11 options
Functions for various network diagnostic tasks:
- Pinging a host
- Resolving DNS names
- Viewing network adapter information
- Performing a traceroute
- Viewing open ports
- Checking internet connectivity
- Viewing IP configuration
- Performing a network speed test (requires speedtest-cli)
- Flushing DNS cache
- Viewing the routing table
Use of various PowerShell cmdlets related to networking
Error handling for network operations
Formatting of output for better readability

This script provides a more comprehensive set of tools for network diagnostics and troubleshooting. It’s suitable for users who want to perform a wider range of network-related tasks and gain more detailed insights into their network configuration and performance.

Note: The speed test function requires the installation of speedtest-cli, which can be installed using the Windows Package Manager (winget) or downloaded from the Ookla website.

Task Manager and Process Monitor

08/08/2024/0 Comments/in Program/by Laszlo Bocso

Description:

This PowerShell script creates a simple task manager and process monitor. It allows users to view running processes, sort them by various criteria, and perform basic actions like stopping a process. The script demonstrates working with processes, user input handling, and basic data manipulation in PowerShell.

Full Script:

# Task Manager and Process Monitor

# Function to display the menu
function Show-Menu {
    Clear-Host
    Write-Host "=== Task Manager and Process Monitor ===" -ForegroundColor Cyan
    Write-Host "1. View all running processes"
    Write-Host "2. View top 10 processes by CPU usage"
    Write-Host "3. View top 10 processes by Memory usage"
    Write-Host "4. Search for a process"
    Write-Host "5. Stop a process"
    Write-Host "6. Exit"
}

# Function to view all running processes
function View-AllProcesses {
    Get-Process | Format-Table Id, ProcessName, CPU, WorkingSet -AutoSize
}

# Function to view top 10 processes by CPU usage
function View-TopCPUProcesses {
    Get-Process | Sort-Object CPU -Descending | Select-Object -First 10 | 
        Format-Table Id, ProcessName, CPU -AutoSize
}

# Function to view top 10 processes by Memory usage
function View-TopMemoryProcesses {
    Get-Process | Sort-Object WorkingSet -Descending | Select-Object -First 10 | 
        Format-Table Id, ProcessName, @{Name="Memory (MB)"; Expression={[math]::Round($_.WorkingSet / 1MB, 2)}} -AutoSize
}

# Function to search for a process
function Search-Process {
    $searchTerm = Read-Host "Enter process name to search"
    Get-Process | Where-Object {$_.ProcessName -like "*$searchTerm*"} | 
        Format-Table Id, ProcessName, CPU, WorkingSet -AutoSize
}

# Function to stop a process
function Stop-UserProcess {
    $processId = Read-Host "Enter the Process ID to stop"
    try {
        Stop-Process -Id $processId -Force -ErrorAction Stop
        Write-Host "Process with ID $processId has been stopped." -ForegroundColor Green
    }
    catch {
        Write-Host "Error: Unable to stop process. $($_.Exception.Message)" -ForegroundColor Red
    }
}

# Main program loop
do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-6)"

    switch ($choice) {
        "1" { View-AllProcesses }
        "2" { View-TopCPUProcesses }
        "3" { View-TopMemoryProcesses }
        "4" { Search-Process }
        "5" { Stop-UserProcess }
        "6" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "6") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "6")

This script includes:

A menu display function for user interaction
Functions to view all processes, top CPU-consuming processes, and top memory-consuming processes
A function to search for processes by name
A function to stop a process by its ID
Use of PowerShell cmdlets like Get-Process, Stop-Process, and Format-Table
Sorting and filtering of process data
Basic error handling when stopping a process
Formatting of output for better readability

The script provides a simple interface for users to monitor and manage system processes, making it suitable for beginners to understand PowerShell scripting concepts, process management, and data manipulation. It also introduces concepts like error handling and custom formatting of output data.

System Information Gatherer

08/08/2024/0 Comments/in Miscellaneous, Program/by Laszlo Bocso

Description:

This PowerShell script is designed for beginners to learn how to gather and display basic system information. It demonstrates how to use various PowerShell cmdlets to retrieve information about the computer’s hardware, operating system, and current user. The script also introduces basic formatting techniques to present the information in a readable manner.

Full Script:

# System Information Gatherer

# Function to get and display system information
function Get-SystemInfo {
    Clear-Host
    Write-Host "=== System Information Gatherer ===" -ForegroundColor Cyan

    # Get computer system information
    $computerSystem = Get-CimInstance CIM_ComputerSystem
    $operatingSystem = Get-CimInstance CIM_OperatingSystem

    # Display basic system information
    Write-Host "`nComputer Name: " -NoNewline -ForegroundColor Yellow
    Write-Host $computerSystem.Name

    Write-Host "Manufacturer: " -NoNewline -ForegroundColor Yellow
    Write-Host $computerSystem.Manufacturer

    Write-Host "Model: " -NoNewline -ForegroundColor Yellow
    Write-Host $computerSystem.Model

    Write-Host "Operating System: " -NoNewline -ForegroundColor Yellow
    Write-Host $operatingSystem.Caption

    Write-Host "OS Version: " -NoNewline -ForegroundColor Yellow
    Write-Host $operatingSystem.Version

    # Get and display CPU information
    $processor = Get-CimInstance CIM_Processor
    Write-Host "`nCPU Information:" -ForegroundColor Green
    Write-Host "Name: $($processor.Name)"
    Write-Host "Cores: $($processor.NumberOfCores)"
    Write-Host "Logical Processors: $($processor.NumberOfLogicalProcessors)"

    # Get and display memory information
    $totalMemory = [math]::Round($computerSystem.TotalPhysicalMemory / 1GB, 2)
    Write-Host "`nMemory Information:" -ForegroundColor Green
    Write-Host "Total Physical Memory: $totalMemory GB"

    # Get and display disk information
    Write-Host "`nDisk Information:" -ForegroundColor Green
    Get-CimInstance CIM_LogicalDisk | Where-Object {$_.DriveType -eq 3} | ForEach-Object {
        $freeSpace = [math]::Round($_.FreeSpace / 1GB, 2)
        $totalSize = [math]::Round($_.Size / 1GB, 2)
        Write-Host "Drive $($_.DeviceID): $freeSpace GB free of $totalSize GB"
    }

    # Get and display current user information
    $currentUser = [System.Security.Principal.WindowsIdentity]::GetCurrent()
    Write-Host "`nCurrent User Information:" -ForegroundColor Green
    Write-Host "Username: $($currentUser.Name)"
}

# Main program
Get-SystemInfo

# Pause to keep the console window open
Read-Host "`nPress Enter to exit..."

This script includes:

A function Get-SystemInfo that gathers and displays various system information
Use of PowerShell cmdlets like Get-CimInstance to retrieve system data
Formatting techniques to make the output more readable (colors, alignment)
Basic math operations to convert bytes to gigabytes
Use of pipeline and Where-Object for filtering disk information
Retrieval of current user information

The script provides a comprehensive overview of the system’s hardware and software configuration, making it useful for beginners to understand how to access and present system information using PowerShell. It also introduces concepts like working with CIM instances, formatting output, and basic data manipulation.

Simple File Management Tool

08/08/2024/0 Comments/in Program/by Laszlo Bocso

Description:

This PowerShell script is designed for beginners to learn basic file management operations. It provides a menu-driven interface that allows users to perform common tasks such as creating directories, listing files, copying files, and deleting files. The script demonstrates the use of functions, user input handling, and basic PowerShell cmdlets for file system operations.

Full Script:

# Simple File Management Tool

# Function to display the menu
function Show-Menu {
    Clear-Host
    Write-Host "=== File Management Tool ==="
    Write-Host "1. Create a new directory"
    Write-Host "2. List files in a directory"
    Write-Host "3. Copy a file"
    Write-Host "4. Delete a file"
    Write-Host "5. Exit"
}

# Function to create a new directory
function Create-NewDirectory {
    $dirName = Read-Host "Enter the name of the new directory"
    New-Item -Path $dirName -ItemType Directory
    Write-Host "Directory created successfully."
}

# Function to list files in a directory
function List-Files {
    $dirPath = Read-Host "Enter the directory path"
    Get-ChildItem -Path $dirPath
}

# Function to copy a file
function Copy-File {
    $sourcePath = Read-Host "Enter the source file path"
    $destPath = Read-Host "Enter the destination path"
    Copy-Item -Path $sourcePath -Destination $destPath
    Write-Host "File copied successfully."
}

# Function to delete a file
function Delete-File {
    $filePath = Read-Host "Enter the file path to delete"
    Remove-Item -Path $filePath
    Write-Host "File deleted successfully."
}

# Main program loop
do {
    Show-Menu
    $choice = Read-Host "Enter your choice (1-5)"

    switch ($choice) {
        "1" { Create-NewDirectory }
        "2" { List-Files }
        "3" { Copy-File }
        "4" { Delete-File }
        "5" { Write-Host "Exiting program..."; break }
        default { Write-Host "Invalid choice. Please try again." }
    }

    if ($choice -ne "5") {
        Read-Host "Press Enter to continue..."
    }
} while ($choice -ne "5")

This script includes:

A menu display function
Functions for each file management operation
A main program loop that handles user input and calls appropriate functions
Basic error handling for invalid user inputs
Use of PowerShell cmdlets like New-Item, Get-ChildItem, Copy-Item, and Remove-Item

The script provides a simple interface for users to perform basic file management tasks, making it suitable for beginners to understand PowerShell scripting concepts and file system operations.

Dr. Scripto’s Adventures: The Mysterious Add-Computer Cmdlet

08/08/2024/0 Comments/in Miscellaneous/by Laszlo Bocso

Dr. Scripto, the famous PowerShell researcher, received a strange call one day. A system administrator from a remote company desperately asked for his help:

“Doctor, please help! I need to add a hundred new computers to the domain, but traditional methods are too slow!”

Dr. Scripto smiled. “Don’t worry, my friend! I have a great cmdlet for that!”

He grabbed his magical PowerShell wand and set off on an adventurous journey. Along the way, he met his old friend, the Add-Computer cmdlet.

“Hello, Add-Computer! Ready for some action?” Dr. Scripto asked.

“Always ready, doc! What do you need?” Add-Computer replied enthusiastically.

They arrived together at the company, where the system administrator was impatiently waiting for them. Dr. Scripto introduced his new friend:

“Here’s Add-Computer! He’ll help us add the machines to the domain in a flash!”

The administrator looked at them skeptically. “Are you sure this little cmdlet can do that?”

Dr. Scripto winked and started writing the script:

$computers = Get-Content "C:\ComputerList.txt"
foreach ($computer in $computers) {
    Add-Computer -ComputerName $computer -DomainName "contoso.com" -Credential $cred -Restart
}

Add-Computer lit up and executed the command in an instant. The administrator was amazed to see all the computers join the domain.

“Incredible! You’re real wizards!” he exclaimed happily.

Dr. Scripto and Add-Computer looked at each other and laughed. “It’s not magic, it’s just the power of PowerShell!” they said in unison.

And so, Dr. Scripto and his new friend, Add-Computer, solved the mysterious domain-joining case, proving that the power within PowerShell is truly capable of wonders!

Dr. Scripto and the Regex Riddle: A PowerShell Tale

08/08/2024/0 Comments/in Dr. Scripto/by Laszlo Bocso

At the PowerShell Academy, excitement was always in the air, but last week’s events would go down in history as one of Dr. Scripto’s most memorable adventures. Our hero found himself face-to-face with the dreaded “Regex Monster,” and the outcome surprised everyone.

It all began on an ordinary Tuesday. Dr. Scripto was giving a lecture on advanced text processing when one of his students, the ever-curious Kriszti, raised a question: “Dr. Scripto, what if we needed to validate complex email addresses?”

Dr. Scripto’s eyes twinkled. “Ah, dear Kriszti, it’s time we delve into the wonderful world of regular expressions!”

With that, Dr. Scripto approached the board and started writing the infamous email validation regex:

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

The students stared at the cryptic string in bewilderment. “It… it looks like a cat walked across the keyboard!” one student remarked.

Dr. Scripto chuckled. “It might seem daunting at first, but trust me, this is one of PowerShell’s most powerful weapons!”

Over the next few hours, Dr. Scripto patiently explained each element of the regex. The students slowly began to understand the pattern’s logic, but they were still skeptical.

“But Dr. Scripto,” Kriszti spoke up, “wouldn’t it be simpler to do this in multiple steps with traditional string operations?”

“Ah, Kriszti, excellent question!” Dr. Scripto replied. “Let’s see, shall we?”

Dr. Scripto then wrote two scripts on the board. One used the regex, the other used traditional string operations. He ran both against a large list of emails.

The regex version finished in seconds. The traditional method… well, it was still running.

The students’ jaws dropped. Dr. Scripto nodded satisfactorily. “You see? Regex isn’t just accurate, it’s incredibly fast too!”

For the rest of the day, the students eagerly dove into the world of regex. They wrote patterns to check phone numbers, validate dates, and Kriszti even created a regex that could recognize Dr. Scripto’s favorite sayings in text.

At the end of the class, Dr. Scripto looked proudly at his students. “Today, you’ve not only learned to use a new tool,” he said, “but you’ve also learned a new language that can help you achieve anything in the world of text!”

As the students left the room, excitedly discussing the new possibilities, Dr. Scripto smiled to himself. “Regex is like PowerShell itself,” he mused, “intimidating at first, but immensely powerful once mastered.”

Kriszti lingered behind, her eyes shining with excitement. “Dr. Scripto,” she said, “I think I’ve fallen in love with regex!”

Dr. Scripto laughed heartily. “My dear Kriszti, welcome to the club! Remember, in the world of PowerShell, regex is like a Swiss Army knife – always handy and surprisingly versatile!”

And so, another day at the PowerShell Academy came to an end, with Dr. Scripto having successfully introduced his students to the magic of regular expressions. As he packed up his PowerShell-themed briefcase, he couldn’t help but wonder what exciting challenges tomorrow would bring.

Latest News

Advanced Network Diagnostics Tool

Task Manager and Process Monitor

System Information Gatherer

Simple File Management Tool

Dr. Scripto’s Adventures: The Mysterious Add-Computer Cmdlet

Dr. Scripto and the Regex Riddle: A PowerShell Tale

Windows PowerShell

Links

Contact

Sitemap