ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ SQL ಸರ್ವರ್‌ನ ಆಟೊಮೇಷನ್: ಫಲಿತಾಂಶವನ್ನು ಸುಂದರವಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ

ಮತ್ತೆ ವ್ಯವಸ್ಥೆಯ ವಿಷಯವನ್ನು ಮುಂದುವರಿಸುವುದು ಝೀರೋ ಟಚ್ PROD RDS ಅಡಿಯಲ್ಲಿ. ಭವಿಷ್ಯದ DBA ಗಳು PROD ಸರ್ವರ್‌ಗಳಿಗೆ ನೇರವಾಗಿ ಸಂಪರ್ಕಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ, ಆದರೆ ಬಳಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಜೆಂಕಿನ್ಸ್ ಸೀಮಿತ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ ಉದ್ಯೋಗಗಳು. DBA ಕೆಲಸವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ಈ ಕಾರ್ಯಾಚರಣೆಯ ಪೂರ್ಣಗೊಂಡ ವರದಿಯೊಂದಿಗೆ ಪತ್ರವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಈ ಫಲಿತಾಂಶಗಳನ್ನು ಬಳಕೆದಾರರಿಗೆ ಪ್ರಸ್ತುತಪಡಿಸುವ ವಿಧಾನಗಳನ್ನು ನೋಡೋಣ.

ಸರಳ ಪಠ್ಯ

ಅತ್ಯಂತ ಕ್ಷುಲ್ಲಕದಿಂದ ಪ್ರಾರಂಭಿಸೋಣ. ಮೊದಲ ವಿಧಾನವು ತುಂಬಾ ಸರಳವಾಗಿದೆ, ಅದರ ಬಗ್ಗೆ ಮಾತನಾಡಲು ನಿಜವಾಗಿಯೂ ಏನೂ ಇಲ್ಲ (ಲೇಖಕರು ಇನ್ನು ಮುಂದೆ ಫ್ರೀಸ್ಟೈಲ್ ಉದ್ಯೋಗಗಳನ್ನು ಬಳಸುತ್ತಾರೆ):

sqlcmd ಏನನ್ನಾದರೂ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಾವು ಅದನ್ನು ಬಳಕೆದಾರರಿಗೆ ಪ್ರಸ್ತುತಪಡಿಸುತ್ತೇವೆ. ಉದಾಹರಣೆಗೆ, ಬ್ಯಾಕಪ್ ಉದ್ಯೋಗಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ:

RDS ಬ್ಯಾಕ್‌ಅಪ್/ರೀಸ್ಟೋರ್ ಅಡಿಯಲ್ಲಿ ಅಸಮಕಾಲಿಕವಾಗಿದೆ ಎಂಬುದನ್ನು ಮರೆಯಬೇಡಿ, ಆದ್ದರಿಂದ ನೀವು ಅದಕ್ಕಾಗಿ ಕಾಯಬೇಕಾಗಿದೆ:

declare @rds table
  (id int, task_type varchar(128), database_name sysname, pct int, duration int, 
   lifecycle varchar(128), taskinfo varchar(max) null, 
   upd datetime, cre datetime,
   s3 varchar(256), ovr int, KMS varchar(256) null)
waitfor delay '00:00:20' 
insert into @rds exec msdb.dbo.rds_task_status @db_name='{db}'
select @xid=max(id) from @rds

again:
waitfor delay '00:00:02'
delete from @rds
insert into @rds exec msdb.dbo.rds_task_status @db_name='{db}' 
# {db} substituted with db name by powershell
select @stat=lifecycle,@info=taskinfo from @rds where id=@xid
if @stat not in ('ERROR','SUCCESS','CANCELLED') goto again

ಎರಡನೇ ವಿಧಾನ, CSV

ಇಲ್ಲಿ ಎಲ್ಲವೂ ತುಂಬಾ ಸರಳವಾಗಿದೆ:

ಆದಾಗ್ಯೂ, CSV ನಲ್ಲಿ ಹಿಂತಿರುಗಿದ ಡೇಟಾವು "ಸರಳ" ಆಗಿದ್ದರೆ ಮಾತ್ರ ಈ ವಿಧಾನವು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನೀವು ಹಿಂತಿರುಗಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಉದಾಹರಣೆಗೆ, ಈ ರೀತಿಯಾಗಿ TOP N CPU ತೀವ್ರವಾದ ಪ್ರಶ್ನೆಗಳ ಪಟ್ಟಿ, CSV ಪ್ರಶ್ನೆಯ ಪಠ್ಯವು ಯಾವುದೇ ಅಕ್ಷರಗಳನ್ನು - ಅಲ್ಪವಿರಾಮಗಳು, ಉಲ್ಲೇಖಗಳು ಮತ್ತು ಲೈನ್ ಬ್ರೇಕ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು ಎಂಬ ಕಾರಣದಿಂದಾಗಿ "ತುಕ್ಕು ಹಿಡಿಯುತ್ತದೆ". ಆದ್ದರಿಂದ, ನಮಗೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಏನಾದರೂ ಬೇಕು.

HTML ನಲ್ಲಿ ಸುಂದರವಾದ ಚಿಹ್ನೆಗಳು

ನಾನು ನಿಮಗೆ ಈಗಿನಿಂದಲೇ ಕೋಡ್ ತುಣುಕನ್ನು ನೀಡುತ್ತೇನೆ

$Header = @"
<style>
TABLE {border-width: 1px; border-style: solid; border-color: black; border-collapse: collapse;}
TH {border-width: 1px; padding: 3px; border-style: solid; border-color: black; background-color: #6495ED;}
TD {border-width: 1px; padding: 3px; border-style: solid; border-color: black;}
</style>
"@
  
$Result = invoke-Sqlcmd -ConnectionString $jstr -Query "select * from DbInv" `
  | Select-Object -Property * -ExcludeProperty "ItemArray", "RowError", "RowState", "Table", "HasErrors"
if ($Result -eq $null) { $cnt = 0; }
elseif ($Result.getType().FullName -eq "System.Management.Automation.PSCustomObject") { $cnt = 1; }
else { $cnt = $Result.Rows.Count; } 
if ($cnt -gt 0) {
  $body = "<h2>My table</h2>"
  $Result | ConvertTo-HTML -Title "Rows" -Head $header -body $body `
    | Out-File "res.log" -Append -Encoding UTF8
  } else {
    "<h3>No data</h3>" | Out-File "res.log" -Append -Encoding UTF8
  }

ಮೂಲಕ, System.Management.Automation.PSCustomObject ಜೊತೆಗಿನ ಸಾಲಿಗೆ ಗಮನ ಕೊಡಿ, ಇದು ಮಾಂತ್ರಿಕವಾಗಿದೆ; ಗ್ರಿಡ್‌ನಲ್ಲಿ ನಿಖರವಾಗಿ ಒಂದು ಸಾಲು ಇದ್ದರೆ, ನಂತರ ಕೆಲವು ಸಮಸ್ಯೆಗಳು ಉದ್ಭವಿಸಿದವು. ಹೆಚ್ಚಿನ ತಿಳುವಳಿಕೆಯಿಲ್ಲದೆ ಇಂಟರ್ನೆಟ್‌ನಿಂದ ಪರಿಹಾರವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ. ಪರಿಣಾಮವಾಗಿ, ನೀವು ಈ ರೀತಿಯ ಔಟ್‌ಪುಟ್ ಫಾರ್ಮ್ಯಾಟ್ ಅನ್ನು ಪಡೆಯುತ್ತೀರಿ:

ರೇಖಾಚಿತ್ರ ಗ್ರಾಫ್ಗಳು

ಎಚ್ಚರಿಕೆ: ಕೆಳಗೆ ಕಿಂಕಿ ಕೋಡ್!
SQL ಸರ್ವರ್‌ನಲ್ಲಿ ಕೊನೆಯ N ನಿಮಿಷಗಳವರೆಗೆ CPU ಅನ್ನು ಪ್ರದರ್ಶಿಸುವ ತಮಾಷೆಯ ಪ್ರಶ್ನೆಯಿದೆ - ಕಾಮ್ರೇಡ್ ಮೇಜರ್ ಎಲ್ಲವನ್ನೂ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ ಎಂದು ಅದು ತಿರುಗುತ್ತದೆ! ಈ ರಸಪ್ರಶ್ನೆ ಪ್ರಯತ್ನಿಸಿ:

DECLARE @ts_now bigint = (SELECT cpu_ticks/(cpu_ticks/ms_ticks) 
  FROM sys.dm_os_sys_info WITH (NOLOCK)); 
SELECT TOP(256) 
  DATEADD(ms, -1 * (@ts_now - [timestamp]), GETDATE()) AS [EventTime],
  SQLProcessUtilization AS [SQLCPU], 
  100 - SystemIdle - SQLProcessUtilization AS [OtherCPU]
FROM (SELECT record.value('(./Record/@id)[1]', 'int') AS record_id, 
  record.value('(./Record/SchedulerMonitorEvent/SystemHealth/SystemIdle)[1]', 'int') 
    AS [SystemIdle], 
  record.value('(./Record/SchedulerMonitorEvent/SystemHealth/ProcessUtilization)[1]', 'int') 
    AS [SQLProcessUtilization], [timestamp] 
  FROM (SELECT [timestamp], CONVERT(xml, record) AS [record] 
  FROM sys.dm_os_ring_buffers WITH (NOLOCK)
  WHERE ring_buffer_type = N'RING_BUFFER_SCHEDULER_MONITOR' 
    AND record LIKE N'%<SystemHealth>%') AS x) AS y 
ORDER BY 1 DESC OPTION (RECOMPILE);

ಈಗ, ಈ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಬಳಸಿ ($Fragment ವೇರಿಯೇಬಲ್)

<table style="width: 100%"><tbody><tr style="background-color: white; height: 2pt;">
  <td style="width: SQLCPU%; background-color: green;"></td>
  <td style="width: OtherCPU%; background-color: blue;"></td>
  <td style="width: REST%; background-color: #C0C0C0;"></td></tr></tbody>
</table>

ನಾವು ಪತ್ರದ ದೇಹವನ್ನು ರಚಿಸಬಹುದು:

$Result = invoke-Sqlcmd -ConnectionString $connstr -Query $Query `
  | Select-Object -Property * -ExcludeProperty `
  "ItemArray", "RowError", "RowState", "Table", "HasErrors"
if ($Result.HasRows) {
  foreach($item in $Result) 
    { 
    $time = $itemEventTime 
    $sqlcpu = $item.SQLCPU
    $other = $itemOtherCPU
    $rest = 100 - $sqlcpu - $other
    $f = $fragment -replace "SQLCPU", $sqlcpu
    $f = $f -replace "OtherCPU", $other
    $f = $f -replace "REST", $rest
    $f | Out-File "res.log" -Append -Encoding UTF8
    }

ಯಾವುದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಹೌದು, ಮಾನ್ಸಿಯರ್‌ಗೆ ವಿಕೃತಿಗಳ ಬಗ್ಗೆ ಸಾಕಷ್ಟು ತಿಳಿದಿದೆ! ಈ ಕೋಡ್ ಒಳಗೊಂಡಿರುವುದು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ: ಪವರ್‌ಶೆಲ್ (ಅದರಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ), SQL, Xquery, HTML. ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು HTML ಗೆ ಸೇರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂಬುದು ವಿಷಾದದ ಸಂಗತಿ (ಇದು ಬರವಣಿಗೆಗಾಗಿ), ಆದರೆ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಪಾಲಿಶ್ ಮಾಡುವುದು (ಇದನ್ನು SQL ನಲ್ಲಿ ಬಳಸಬಹುದು) ಪ್ರತಿಯೊಬ್ಬರ ಕರ್ತವ್ಯವಾಗಿದೆ!

SQL ಪ್ರೊಫೈಲರ್ ಟ್ರೇಸ್ ಔಟ್‌ಪುಟ್

TextData ಕ್ಷೇತ್ರದಿಂದಾಗಿ ಟ್ರೇಸ್ CSV ಗೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿದೆ. ಆದರೆ ಪತ್ರದಲ್ಲಿ ಟ್ರೇಸ್ ಗ್ರಿಡ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸುವುದು ಸಹ ವಿಚಿತ್ರವಾಗಿದೆ - ಗಾತ್ರದ ಕಾರಣದಿಂದಾಗಿ ಮತ್ತು ಈ ಡೇಟಾವನ್ನು ಹೆಚ್ಚಿನ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮಾಡುತ್ತೇವೆ: ನಾವು ಮೂಲಕ ಕರೆ ಮಾಡುತ್ತೇವೆ ಮನವಿ-SqlCmd ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಕ್ರಿಪ್ಟ್, ಅದರ ಆಳದಲ್ಲಿ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ

select 
  SPID,EventClass,TextData,
  Duration,Reads,Writes,CPU,
  StartTime,EndTime,DatabaseName,HostName,
  ApplicationName,LoginName
   from ::fn_trace_gettable ( @filename , default )  

ಮುಂದೆ, ಆನ್ ಸ್ನೇಹಿತ DBA ಮೂಲಕ ಪ್ರವೇಶಿಸಬಹುದಾದ ಸರ್ವರ್‌ನಲ್ಲಿ, ಖಾಲಿ ಟೆಂಪ್ಲೇಟ್‌ನೊಂದಿಗೆ ಟ್ರೇಸಸ್ ಡೇಟಾಬೇಸ್ ಇದೆ, ಮಾದರಿ ಪ್ಲೇಟ್, ಎಲ್ಲಾ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕಾಲಮ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ಸಿದ್ಧವಾಗಿದೆ. ನಾವು ಈ ಮಾದರಿಯನ್ನು ಅನನ್ಯ ಹೆಸರಿನೊಂದಿಗೆ ಹೊಸ ಕೋಷ್ಟಕಕ್ಕೆ ನಕಲಿಸುತ್ತೇವೆ:

$dt = Get-Date -format "yyyyMMdd"
$tm = Get-Date -format "hhmmss"
$tableName = $srv + "_" + $dt + "_" + $tm
$copytab = "select * into " + $tableName + " from Model"
invoke-SqlCmd -ConnectionString $tstr -Query $copytab 

ಮತ್ತು ಈಗ ನಾವು ಅದನ್ನು ಬಳಸಿಕೊಂಡು ನಮ್ಮ ಜಾಡನ್ನು ಬರೆಯಬಹುದು ಡೇಟಾ.SqlClient.SqlBulkCopy - ನಾನು ಈಗಾಗಲೇ ಮೇಲಿನ ಉದಾಹರಣೆಯನ್ನು ನೀಡಿದ್ದೇನೆ. ಹೌದು, ಟೆಕ್ಸ್ಟ್‌ಡೇಟಾದಲ್ಲಿ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಮರೆಮಾಚುವುದು ಸಹ ಒಳ್ಳೆಯದು:

# mask data
foreach ($Row in $Result)
{ 
  $v = $Row["TextData"]
  $v = $v -replace "'([^']{2,})'", "'str'" -replace "[0-9][0-9]+", '999'
  $Row["TextData"] = $v
}

ನಾವು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಅಕ್ಷರಗಳ ಉದ್ದವನ್ನು 999 ನೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತೇವೆ ಮತ್ತು ನಾವು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಅಕ್ಷರಗಳನ್ನು 'str' ನೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತೇವೆ. 0 ರಿಂದ 9 ರವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಧ್ವಜಗಳಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ನಾವು ಅವುಗಳನ್ನು ಸ್ಪರ್ಶಿಸುವುದಿಲ್ಲ, ಹಾಗೆಯೇ ಖಾಲಿ ಮತ್ತು ಏಕ-ಅಕ್ಷರದ ತಂತಿಗಳು - 'Y', 'N', ಇತ್ಯಾದಿಗಳು ಅವುಗಳಲ್ಲಿ ಹೆಚ್ಚಾಗಿ ಕಂಡುಬರುತ್ತವೆ.

ನಮ್ಮ ಜೀವನಕ್ಕೆ ಸ್ವಲ್ಪ ಬಣ್ಣವನ್ನು ಸೇರಿಸೋಣ (ಕಟ್ಟುನಿಟ್ಟಾಗಿ 18+)

ಕೋಷ್ಟಕಗಳಲ್ಲಿ, ಗಮನ ಅಗತ್ಯವಿರುವ ಕೋಶಗಳನ್ನು ನೀವು ಹೆಚ್ಚಾಗಿ ಹೈಲೈಟ್ ಮಾಡಲು ಬಯಸುತ್ತೀರಿ. ಉದಾಹರಣೆಗೆ, FAILS, ಉನ್ನತ ಮಟ್ಟದ ವಿಘಟನೆ, ಇತ್ಯಾದಿ. ಸಹಜವಾಗಿ, ಇದನ್ನು ಬೇರ್ SQL ನಲ್ಲಿ ಮಾಡಬಹುದು, ಪ್ರಿಂಟ್ ಬಳಸಿ HTML ಅನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ HTML ಗೆ ಫೈಲ್ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿಸಬಹುದು:

declare @body varchar(max), @chunk varchar(max)
set @body='<font face="Lucida Console" size="3">'
set @body=@body+'<b>Server name: '+@@servername+'</b><br>'
set @body=@body+'<br><br>'
set @body=@body+'<table><tr><th>Job</th><th>Last Run</th><th>Avg Duration, sec</th><th>Last Run, Sec</th><th>Last Status</th></tr>'
print @body

DECLARE tab CURSOR FOR SELECT '<tr><td>'+name+'</td><td>'+
  LastRun+'</td><td>'+
  convert(varchar,AvgDuration)+'</td><td>'+
  convert(varchar,LastDuration)+'</td><td>'+
    case when LastStatus<>'Succeeded' then '<font color="red">' else '' end+
      LastStatus+
      case when LastStatus<>'Succeeded' then '</font>' else '' end+
     +'</td><td>'
  from #j2
OPEN tab;  
FETCH NEXT FROM tab into @chunk
WHILE @@FETCH_STATUS = 0  
BEGIN
  print @chunk
  FETCH NEXT FROM tab into @chunk;  
END  
CLOSE tab;  
DEALLOCATE tab;
print '</table>'

ನಾನು ಅಂತಹ ಕೋಡ್ ಅನ್ನು ಏಕೆ ಬರೆದೆ?

ಆದರೆ ಅದಕ್ಕಿಂತ ಸುಂದರವಾದ ಪರಿಹಾರವಿದೆ. HTML ಗೆ ಪರಿವರ್ತಿಸಿ ಜೀವಕೋಶಗಳನ್ನು ಬಣ್ಣ ಮಾಡಲು ನಮಗೆ ಅವಕಾಶ ನೀಡುವುದಿಲ್ಲ, ಆದರೆ ವಾಸ್ತವವಾಗಿ ನಂತರ ನಾವು ಅದನ್ನು ಮಾಡಬಹುದು. ಉದಾಹರಣೆಗೆ, ನಾವು 80 ಕ್ಕಿಂತ ಹೆಚ್ಚು ಮತ್ತು 90 ಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ವಿಘಟನೆಯ ಮಟ್ಟವನ್ನು ಹೊಂದಿರುವ ಕೋಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ. ನಾವು ಶೈಲಿಗಳನ್ನು ಸೇರಿಸೋಣ:

<style>
.SQLmarkup-red { color: red; background-color: yellow; }
.SQLmarkup-yellow { color: black; background-color: #FFFFE0; }
.SQLmarkup-default { color: black; background-color: white; }
</style>

ಪ್ರಶ್ನೆಯಲ್ಲಿಯೇ ನಾವು ನಕಲಿ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸುತ್ತೇವೆ ತಕ್ಷಣ ಮೊದಲು ನಾವು ಬಣ್ಣ ಮಾಡಲು ಬಯಸುವ ಕಾಲಮ್. ಅಂಕಣವನ್ನು ಕರೆಯಬೇಕು SQLmarkup-ಏನೋ:

case  
  when ps.avg_fragmentation_in_percent>=90.0 then 'SQLmarkup-red'
  when ps.avg_fragmentation_in_percent>=80.0 then 'SQLmarkup-yellow'
  else 'SQLmarkup-default' 
  end as [SQLmarkup-1], 
ps.avg_fragmentation_in_percent, 

ಈಗ, ಪವರ್‌ಶೆಲ್‌ನಿಂದ ರಚಿಸಲಾದ HTML ಅನ್ನು ಸ್ವೀಕರಿಸಿದ ನಂತರ, ನಾವು ಹೆಡರ್‌ನಿಂದ ನಕಲಿ ಕಾಲಮ್ ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತೇವೆ ಮತ್ತು ಡೇಟಾದ ದೇಹದಲ್ಲಿ ನಾವು ಮೌಲ್ಯವನ್ನು ಕಾಲಮ್‌ನಿಂದ ಶೈಲಿಗೆ ವರ್ಗಾಯಿಸುತ್ತೇವೆ. ಇದನ್ನು ಕೇವಲ ಎರಡು ಪರ್ಯಾಯಗಳೊಂದಿಗೆ ಮಾಡಲಾಗುತ್ತದೆ:

$html = $html `
  -replace "<th>SQLmarkup[^<]*</th>", "" `
  -replace "<td>SQLmarkup-(.+?)</td><td>",'<td class="SQLmarkup-$1">'

ಫಲಿತಾಂಶ:


ಸೊಗಸಲ್ಲವೇ? ಇಲ್ಲವಾದರೂ, ಈ ಬಣ್ಣವು ನನಗೆ ಏನನ್ನಾದರೂ ನೆನಪಿಸುತ್ತದೆ


ಮೂಲ: www.habr.com