ඉක්මනින් හෝ පසුව, ඕනෑම VMware පද්ධති පරිපාලකයෙක් සාමාන්‍ය කාර්යයන් ස්වයංක්‍රීය කිරීමට පැමිණේ. එය විධාන රේඛාවෙන් ආරම්භ වේ, පසුව PowerShell හෝ VMware PowerCLI පැමිණේ.
ISE දියත් කිරීමට සහ “යම් ආකාරයක මැජික්” හේතුවෙන් ක්රියා කරන මොඩියුල වලින් සම්මත cmdlets භාවිතා කිරීමට වඩා ඔබ PowerShell ප්‍රගුණ කර ඇතැයි සිතමු. ඔබ අතථ්‍ය යන්ත්‍ර සිය ගණනකින් ගණන් කිරීම ආරම්භ කරන විට, කුඩා පරිමාණයෙන් උපකාර වන ස්ක්‍රිප්ට් විශාල පරිමාණයෙන් සැලකිය යුතු ලෙස මන්දගාමීව ධාවනය වන බව ඔබට පෙනී යනු ඇත.
මෙම අවස්ථාවේ දී, මෙවලම් 2 ක් උපකාරී වනු ඇත:
- PowerShell ධාවන අවකාශය - වෙනම නූල් වල ක්‍රියාවලි ක්‍රියාත්මක කිරීම සමාන්තරව කිරීමට ඔබට ඉඩ සලසන ප්‍රවේශයක්;
- ලබාගන්න-දර්ශනය – මූලික PowerCLI ශ්‍රිතයක්, Windows හි Get-WMIObject හි ප්රතිසමයකි. මෙම cmdlet මඟින් වස්තු සමඟ ඇති වස්තූන් අදින්නේ නැත, නමුත් සරල දත්ත වර්ග සහිත සරල වස්තුවක ආකාරයෙන් තොරතුරු ලබා ගනී. බොහෝ අවස්ථාවලදී එය වේගයෙන් පිටතට පැමිණේ.
ඊළඟට, මම එක් එක් මෙවලම ගැන කෙටියෙන් කතා කර භාවිතයේ උදාහරණ පෙන්වමි. අපි නිශ්චිත ස්ක්‍රිප්ට් විශ්ලේෂණය කර එකක් අනෙකට වඩා හොඳින් ක්රියා කරන්නේ කවදාදැයි බලමු. යන්න!
පළමු අදියර: ධාවන අවකාශය
එබැවින්, ප්‍රධාන මොඩියුලයෙන් පිටත කාර්යයන් සමාන්තරව සැකසීම සඳහා Runspace නිර්මාණය කර ඇත. ඇත්ත වශයෙන්ම, ඔබට යම් මතකයක්, ප්‍රොසෙසරයක් ආදිය විනාශ කරන වෙනත් ක්‍රියාවලියක් දියත් කළ හැක. ඔබේ ස්ක්‍රිප්ට් එක මිනිත්තු කිහිපයකින් ක්‍රියාත්මක වී ගිගාබයිට් මතකයක් පරිභෝජනය කරන්නේ නම්, බොහෝ විට ඔබට Runspace අවශ්ය නොවනු ඇත. නමුත් දස දහස් ගණනක් වස්තූන් සඳහා ස්ක්‍රිප්ට් සඳහා එය අවශ්ය වේ.
ඔබට මෙහි ඉගෙනීම ආරම්භ කළ හැකිය:
Runspace භාවිතයෙන් ලබා දෙන්නේ කුමක්ද:
- ක්‍රියාත්මක කරන ලද විධාන ලැයිස්තුව සීමා කිරීමෙන් වේගය,
- කාර්යයන් සමාන්තරව ක්‍රියාත්මක කිරීම,
- ආරක්ෂාව.
Runspace උපකාර වන විට අන්තර්ජාලයෙන් උදාහරණයක් මෙන්න:
“ගබඩා ආරවුල යනු vSphere හි නිරීක්ෂණය කිරීමට අපහසුම ප්‍රමිතික වලින් එකකි. vCenter තුළ, ඔබට ගොස් වැඩිපුර ගබඩා සම්පත් පරිභෝජනය කරන්නේ කුමන VM දැයි බැලීමට නොහැක. වාසනාවකට මෙන්, ඔබට PowerShell වෙත ස්තුති වන්නට මිනිත්තු කිහිපයකින් මෙම දත්ත රැස් කළ හැක.
VMware පද්ධති පරිපාලකයින්ට ඉක්මනින් vCenter පුරා සෙවීමට සහ ඔවුන්ගේ සාමාන්‍ය පරිභෝජනය පිළිබඳ දත්ත සහිත VM ලැයිස්තුවක් ලබා ගැනීමට ඉඩ සලසන ස්ක්‍රිප්ට් එකක් මම බෙදා ගන්නෙමි.
ස්ක්‍රිප්ට් එක එක් එක් ESXi ධාරකයට තමන්ගේම VM වලින් පරිභෝජන තොරතුරු වෙනම Runspace එකකින් රැස් කර ගැනීමටත්, සම්පූර්ණ කිරීම වහාම වාර්තා කිරීමටත් PowerShell ධාවන අවකාශයන් භාවිතා කරයි. මෙය ධාරක හරහා පුනරාවර්තනය වී එක් එක් ඉල්ලීම සම්පූර්ණ කරන තෙක් බලා සිටීම වෙනුවට PowerShell හට වහාම රැකියා වසා දැමීමට ඉඩ සලසයි.මූලාශ්රය:
පහත අවස්ථාවෙහිදී, Runspace තවදුරටත් ප්රයෝජනවත් නොවේ:
“මම උත්සාහ කරන්නේ VM එකකින් දත්ත විශාල ප්‍රමාණයක් එකතු කර අවශ්ය විට නව දත්ත ලියන ස්ක්‍රිප්ට් එකක් ලිවීමටයි. ගැටලුව වන්නේ VM විශාල ප්‍රමාණයක් තිබීම සහ තත්පර 5-8 ක් එක් යන්ත්‍රයක් සඳහා වැය වීමයි.
මූලාශ්රය:
මෙහිදී ඔබට Get-View අවශ්ය වනු ඇත, අපි එය වෙත යමු.
දෙවන අදියර: Get-Vew
Get-View ප්රයෝජනවත් වන්නේ මන්දැයි තේරුම් ගැනීමට, සාමාන්යයෙන් cmdlets ක්රියා කරන ආකාරය මතක තබා ගැනීම වටී.
API විමර්ශන පොත් අධ්‍යයනය කිරීම සහ ඊළඟ රෝදය ප්‍රතිනිර්මාණය කිරීම අවශ්ය නොවී පහසුවෙන් තොරතුරු ලබා ගැනීමට Cmdlets අවශ්ය වේ. පැරණි දිනවල කේත පේළි සියයක් හෝ දෙකක් ගත් දේ, PowerShell ඔබට එක් විධානයකින් කිරීමට ඉඩ සලසයි. අපි මෙම පහසුව සඳහා වේගයෙන් ගෙවන්නෙමු. cmdlets තුළම මැජික් නොමැත: එකම පිටපත, නමුත් පහළ මට්ටමේ, හිරු ඉන්දියාවේ සිට පැමිණි ස්වාමියෙකුගේ දක්ෂ දෑතින් ලියා ඇත.
දැන්, Get-View සමඟ සංසන්දනය කිරීම සඳහා, අපි Get-VM cmdlet ගනිමු: එය අතථ්‍ය යන්ත්‍රයට ප්‍රවේශ වී සංයුක්ත වස්තුවක් ආපසු ලබා දෙයි, එනම්, එය එයට වෙනත් අදාළ වස්තූන් අමුණයි: VMHost, Datastore, ආදිය.
Get-View එහි ස්ථානයේ ඇති වස්තුවට අනවශ්‍ය කිසිවක් එකතු නොකරයි. එපමනක් නොව, අපට අවශ්ය තොරතුරු මොනවාදැයි දැඩි ලෙස සඳහන් කිරීමට ඉඩ සලසයි, ප්රතිදාන වස්තුව පහසු කරනු ඇත. සාමාන්යයෙන් Windows Server හි සහ විශේෂයෙන්ම Hyper-V හි, Get-WMIObject cmdlet සෘජු ප්රතිසමයකි - අදහස හරියටම සමාන වේ.
ලක්ෂ්‍ය වස්තු මත සාමාන්‍ය මෙහෙයුම් සඳහා Get-View අපහසු වේ. නමුත් වස්තු දහස් ගණනක් සහ දස දහස් ගණනක් යන විට එයට මිලක් නැත.
ඔබට VMware බ්ලොග් අඩවියෙන් වැඩිදුර කියවිය හැකිය:
දැන් මම ඔබට සැබෑ නඩුවක් භාවිතා කර සියල්ල පෙන්වන්නම්.
VM එකක් බාගැනීමට ස්ක්‍රිප්ට් ලිවීම
දවසක් මගේ සගයා මගෙන් ඇහුවා එයාගේ පිටපත ප්‍රශස්ත කරන්න කියලා. කාර්යය පොදු පුරුද්දකි: සියලුම VMs අනුපිටපත් cloud.uuid පරාමිතියකින් සොයා ගන්න (ඔව්, vCloud Director හි VM ක්ලෝන කිරීමේදී මෙය කළ හැකිය).
මතකයට එන පැහැදිලි විසඳුම වන්නේ:
- සියලුම VM ලැයිස්තුවක් ලබා ගන්න.
- ලිස්ට් එක කොහොම හරි විග්‍රහ කරන්න.
මුල් පිටපත මෙම සරල පිටපත විය:
function Get-CloudUUID1 {
# Получаем список всех ВМ
$vms = Get-VM
$report = @()
# Обрабатываем каждый объект, получая из него только 2 свойства: Имя ВМ и Cloud UUID.
# Заносим данные в новый PS-объект с полями VM и UUID
foreach ($vm in $vms)
{
$table = "" | select VM,UUID
$table.VM = $vm.name
$table.UUID = ($vm | Get-AdvancedSetting -Name cloud.uuid).Value
$report += $table
}
# Возвращаем все объекты
$report
}
# Далее РУКАМИ парсим полученный результатසෑම දෙයක්ම අතිශයින්ම සරල හා පැහැදිලි ය. එය කෝපි විවේකයක් සමඟ මිනිත්තු කිහිපයකින් ලිවිය හැකිය. පෙරීම මත ඉස්කුරුප්පු කර එය සිදු කර ඇත.
නමුත් අපි කාලය මැන බලමු:
විනාඩි 2 තත්පර 47 VMs 10k පමණ සකසන විට. ප්‍රසාද දීමනාවක් යනු පෙරහන් නොමැති වීම සහ ප්‍රතිඵල අතින් වර්ග කිරීමට ඇති අවශ්‍යතාවයයි. පැහැදිලිවම, පිටපතට ප්‍රශස්තකරණය අවශ්ය වේ.
ඔබට එකවර vCenter වෙතින් ධාරක ප්‍රමිතික ලබා ගැනීමට අවශ්ය වූ විට හෝ වස්තු දස දහස් ගණනක් සැකසීමට අවශ්ය වූ විට මුලින්ම ගලවා ගැනීමට පැමිණෙන්නේ Runspaces ය. මෙම ප්රවේශය ගෙන එන්නේ කුමක්දැයි බලමු.
පළමු වේගය සක්රිය කරන්න: PowerShell Runspaces
මෙම ස්ක්‍රිප්ටය සඳහා මතකයට එන පළමු දෙය නම් ලූපය අනුක්‍රමිකව නොව සමාන්තර නූල් වලින් ක්‍රියාත්මක කිරීම, සියලු දත්ත එක් වස්තුවකට එකතු කර පෙරීමයි.
නමුත් ගැටලුවක් තිබේ: PowerCLI අපට බොහෝ ස්වාධීන සැසි vCenter වෙත විවෘත කිරීමට ඉඩ නොදෙන අතර විහිලු දෝෂයක් ඇති කරයි:
You have modified the global:DefaultVIServer and global:DefaultVIServers system variables. This is not allowed. Please reset them to $null and reconnect to the vSphere server.මෙය විසඳීමට, ඔබ මුලින්ම ප්‍රවාහය තුළ සැසි තොරතුරු ලබා දිය යුතුය. PowerShell ක්රියා කරන්නේ ශ්‍රිතයකට හෝ ScriptBlock එකකට පරාමිතියක් ලෙස ලබා දිය හැකි වස්තූන් සමඟ බව අපි මතක තබා ගනිමු. $global:DefaultVIServers (Connect-VIServer with the -NotDefault යතුර) මගහැර, එවැනි වස්තුවක ස්වරූපයෙන් සැසිය සම්මත කරමු:
$ConnectionString = @()
foreach ($vCenter in $vCenters)
{
try {
$ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -AllLinked -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
}
catch {
if ($er.Message -like "*not part of a linked mode*")
{
try {
$ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
}
catch {
throw $_
}
}
else {
throw $_
}
}
}දැන් Runspace Pools හරහා multithreading ක්‍රියාත්මක කරමු.
ඇල්ගොරිතම පහත පරිදි වේ:
- අපි සියලුම VMs ලැයිස්තුවක් ලබා ගනිමු.
- සමාන්තර ප්‍රවාහ වලදී අපට cloud.uuid ලැබේ.
- අපි ප්‍රවාහ වලින් දත්ත එක් වස්තුවකට එකතු කරමු.
- අපි CloudUUID ක්ෂේත්‍රයේ අගය අනුව එය කාණ්ඩගත කිරීමෙන් එය පෙරහන් කරන්නෙමු: අද්විතීය අගයන් 1 ට වඩා වැඩි ඒවා අප සොයන VM වේ.
එහි ප්‍රතිඵලයක් ලෙස අපට ස්ක්‍රිප්ට් එක ලැබේ.
function Get-VMCloudUUID {
param (
[string[]]
[ValidateNotNullOrEmpty()]
$vCenters = @(),
[int]$MaxThreads,
[System.Management.Automation.PSCredential]
[System.Management.Automation.Credential()]
$Credential
)
$ConnectionString = @()
# Создаем объект с сессионным ключом
foreach ($vCenter in $vCenters)
{
try {
$ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -AllLinked -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
}
catch {
if ($er.Message -like "*not part of a linked mode*")
{
try {
$ConnectionString += Connect-VIServer -Server $vCenter -Credential $Credential -NotDefault -Force -ErrorAction stop -WarningAction SilentlyContinue -ErrorVariable er
}
catch {
throw $_
}
}
else {
throw $_
}
}
}
# Получаем список всех ВМ
$Global:AllVMs = Get-VM -Server $ConnectionString
# Поехали!
$ISS = [system.management.automation.runspaces.initialsessionstate]::CreateDefault()
$RunspacePool = [runspacefactory]::CreateRunspacePool(1, $MaxThreads, $ISS, $Host)
$RunspacePool.ApartmentState = "MTA"
$RunspacePool.Open()
$Jobs = @()
# ScriptBlock с магией!)))
# Именно он будет выполняться в потоке
$scriptblock = {
Param (
$ConnectionString,
$VM
)
$Data = $VM | Get-AdvancedSetting -Name Cloud.uuid -Server $ConnectionString | Select-Object @{N="VMName";E={$_.Entity.Name}},@{N="CloudUUID";E={$_.Value}},@{N="PowerState";E={$_.Entity.PowerState}}
return $Data
}
# Генерируем потоки
foreach($VM in $AllVMs)
{
$PowershellThread = [PowerShell]::Create()
# Добавляем скрипт
$null = $PowershellThread.AddScript($scriptblock)
# И объекты, которые передадим в качестве параметров скрипту
$null = $PowershellThread.AddArgument($ConnectionString)
$null = $PowershellThread.AddArgument($VM)
$PowershellThread.RunspacePool = $RunspacePool
$Handle = $PowershellThread.BeginInvoke()
$Job = "" | Select-Object Handle, Thread, object
$Job.Handle = $Handle
$Job.Thread = $PowershellThread
$Job.Object = $VM.ToString()
$Jobs += $Job
}
# Ставим градусник, чтобы наглядно отслеживать выполнение заданий
# И здесь же прибиваем отработавшие задания
While (@($Jobs | Where-Object {$_.Handle -ne $Null}).count -gt 0)
{
$Remaining = "$($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False}).object)"
If ($Remaining.Length -gt 60) {
$Remaining = $Remaining.Substring(0,60) + "..."
}
Write-Progress -Activity "Waiting for Jobs - $($MaxThreads - $($RunspacePool.GetAvailableRunspaces())) of $MaxThreads threads running" -PercentComplete (($Jobs.count - $($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False}).count)) / $Jobs.Count * 100) -Status "$(@($($Jobs | Where-Object {$_.Handle.IsCompleted -eq $False})).count) remaining - $remaining"
ForEach ($Job in $($Jobs | Where-Object {$_.Handle.IsCompleted -eq $True})){
$Job.Thread.EndInvoke($Job.Handle)
$Job.Thread.Dispose()
$Job.Thread = $Null
$Job.Handle = $Null
}
}
$RunspacePool.Close() | Out-Null
$RunspacePool.Dispose() | Out-Null
}
function Get-CloudUUID2
{
[CmdletBinding()]
param(
[string[]]
[ValidateNotNullOrEmpty()]
$vCenters = @(),
[int]$MaxThreads = 50,
[System.Management.Automation.PSCredential]
[System.Management.Automation.Credential()]
$Credential)
if(!$Credential)
{
$Credential = Get-Credential -Message "Please enter vCenter credentials."
}
# Вызов функции Get-VMCloudUUID, где мы распараллеливаем операцию
$AllCloudVMs = Get-VMCloudUUID -vCenters $vCenters -MaxThreads $MaxThreads -Credential $Credential
$Result = $AllCloudVMs | Sort-Object Value | Group-Object -Property CloudUUID | Where-Object -FilterScript {$_.Count -gt 1} | Select-Object -ExpandProperty Group
$Result
}මෙම ස්ක්‍රිප්ටයේ ඇති අලංකාරය නම් එය සරලව ScriptBlock සහ ප්‍රවාහයට ලබා දෙන පරාමිතීන් ප්‍රතිස්ථාපනය කිරීමෙන් සමාන වෙනත් අවස්ථා වලදී භාවිතා කළ හැකි වීමයි. එය ගසාකන්න!
අපි කාලය මනිමු:
තත්පර 55 යි. එය වඩා හොඳයි, නමුත් එය තවමත් වේගවත් විය හැක.
අපි දෙවන වේගයට යමු: GetView
වැරැද්ද කුමක්දැයි සොයා බලමු.
පළමුවෙන්ම සහ ප්‍රධාන වශයෙන්, Get-VM cmdlet ක්‍රියාත්මක වීමට බොහෝ කාලයක් ගතවේ.
දෙවනුව, Get-AdvancedOptions cmdlet සම්පූර්ණ කිරීමට ඊටත් වඩා වැඩි කාලයක් ගතවේ.
අපි මුලින්ම දෙවැන්න සමඟ කටයුතු කරමු.
Get-AdvancedOptions තනි තනි VM වස්තු සඳහා පහසු වේ, නමුත් බොහෝ වස්තු සමඟ වැඩ කිරීමේදී ඉතා අවුල් සහගතය. අපට අථත්‍ය යන්ත්‍ර වස්තුවෙන් (Get-VM) එකම තොරතුරු ලබා ගත හැකිය. එය ExtensionData වස්තුවේ හොඳින් තැන්පත් වී ඇත. පෙරීමෙන් සන්නද්ධව, අපි අවශ්ය දත්ත ලබා ගැනීමේ ක්රියාවලිය වේගවත් කරමු.
අතේ සුළු චලනයකින් මෙය මෙසේය.
VM | Get-AdvancedSetting -Name Cloud.uuid -Server $ConnectionString | Select-Object @{N="VMName";E={$_.Entity.Name}},@{N="CloudUUID";E={$_.Value}},@{N="PowerState";E={$_.Entity.PowerState}}මෙයට හැරේ:
$VM | Where-Object {($_.ExtensionData.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value -ne $null} | Select-Object @{N="VMName";E={$_.Name}},@{N="CloudUUID";E={($_.ExtensionData.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value}},@{N="PowerState";E={$_.summary.runtime.powerstate}}ප්‍රතිදානය Get-AdvancedOptions වලට සමාන වේ, නමුත් එය බොහෝ වාරයක් වේගයෙන් ක්රියා කරයි.
දැන් Get-VM වෙත. එය සංකීර්ණ වස්තූන් සමඟ කටයුතු කරන නිසා එය වේගවත් නොවේ. තාර්කික ප්‍රශ්නයක් පැන නගී: අපට VM හි නම, එහි තත්වය සහ උපක්‍රමශීලී ගුණාංගයක වටිනාකම පමණක් අවශ්ය වූ විට, අපට අමතර තොරතුරු සහ භයානක PSObject අවශ්ය වන්නේ ඇයි?
මීට අමතරව, Get-AdvancedOptions ආකාරයෙන් ඇති බාධාව ස්ක්‍රිප්ට් එකෙන් ඉවත් කර ඇත. සැසියක් භාර දෙන විට squat නූල් හරහා මන්දගාමී කාර්යයක් සමාන්තර කිරීමට තවදුරටත් අවශ්ය නොවන බැවින් Runspace Pools භාවිතා කිරීම දැන් අධික ලෙස ක්රියා කරයි. මෙවලම හොඳයි, නමුත් මෙම නඩුව සඳහා නොවේ.
ExtensionData හි ප්‍රතිදානය දෙස බලමු: එය Get-View වස්තුවකට වඩා වැඩි දෙයක් නොවේ.
PowerShell masters හි පැරණි තාක්ෂණයට අපි කතා කරමු: පෙරහන් භාවිතා කරමින් එක් පේළියක්, වර්ග කිරීම සහ කණ්ඩායම් කිරීම. පෙර පැවති සියලුම භීෂණය අලංකාර ලෙස එක් පේළියකට කඩා එක් සැසියකදී ක්‍රියාත්මක වේ:
$AllVMs = Get-View -viewtype VirtualMachine -Property Name,Config.ExtraConfig,summary.runtime.powerstate | Where-Object {($_.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value -ne $null} | Select-Object @{N="VMName";E={$_.Name}},@{N="CloudUUID";E={($_.Config.ExtraConfig | Where-Object {$_.key -eq "cloud.uuid"}).Value}},@{N="PowerState";E={$_.summary.runtime.powerstate}} | Sort-Object CloudUUID | Group-Object -Property CloudUUID | Where-Object -FilterScript {$_.Count -gt 1} | Select-Object -ExpandProperty Groupඅපි කාලය මනිමු:
9 තත්පර අපේක්ෂිත තත්ත්වය අනුව පෙරීම සහිත 10k ආසන්න වස්තූන් සඳහා. මහා!
ඒ වෙනුවට අවසාන කාල පරිච්ඡේදය
පිළිගත හැකි ප්රතිඵලය සෘජුවම රඳා පවතින්නේ මෙවලම තෝරා ගැනීම මතය. එය සාක්ෂාත් කර ගැනීම සඳහා හරියටම තෝරා ගත යුතු දේ නිශ්චිතවම පැවසීම බොහෝ විට දුෂ්කර ය. ස්ක්‍රිප්ට් වේගවත් කිරීම සඳහා ලැයිස්තුගත කර ඇති සෑම ක්‍රමයක්ම එහි අදාළත්වයේ සීමාවන් තුළ හොඳය. ඔබගේ යටිතල ව්‍යුහය තුළ ක්‍රියාවලි ස්වයංක්‍රීයකරණය සහ ප්‍රශස්තකරණය පිළිබඳ මූලික කරුණු අවබෝධ කර ගැනීමේ දුෂ්කර කාර්යයේදී මෙම ලිපිය ඔබට උපකාර කරනු ඇතැයි මම බලාපොරොත්තු වෙමි.
PS: ලිපිය සකස් කිරීමේදී සියලු ප්‍රජා සාමාජිකයින්ගේ උපකාරය සහ සහයෝගය සඳහා කතුවරයා ස්තුති කරයි. පාද ඇති අය පවා. ඒවගේම කකුල් නැති අය පවා බෝවකු වගේ.
මූලාශ්රය: www.habr.com