DOS: SystemInfo

Problem Statement:

Using DOS command to get all the information pertaining to the sytem.

Solution:

Use of Dos coammnd: systeminfo.

Below is a typical output of systeminfo command on DOS prompt.

Using Perl Script to get OS Name:

use strict;

system("systeminfo find \"OS Name\" > C:\\temp\\temp.txt");

open(FH, "<", "C:\\temp\\temp.txt");

my $contents = ;

my @osInfo = split(':', $contents);

$osInfo[1] = s/\s\s+//g;

print $osInfo[1];

#This script would print the OS Name. Like it would print "Microsoft Windows 7 Utlimate" if run on Windows 7 - Ultimate Version of OS.

Perl: Using WMI in Perl

Problem Statement: Using WMI in Perl

Solution:

use Win32::OLE;

$instances = Win32::OLE->GetObject("winmgmts:\\\\localhost\\root\\CIMV2")->InstancesOf(Win32_LogicalDisk) or die "Cant access WMI";

for my $proc (in $instances)

{

printf "%5d %7d \n", $proc->{ProcessId}, $proc->{WorkingSetSize};

}

More examples on: http://www.perlmonks.org

Python: Threading in Python

Problem Statement:
Demonstrate the usage of threading in python.

Scripts:
Let's consider an example where we have two scripts, one of them is the "main.py" script that can be considered as parent and the other that would run in threads "log.py".

Let's first take a look at
"log.py"
---------
import time

 class log:
  def __init__(self, times):
   self.times = times
   self._bOn = True

  def start(self):
   while (self._bOn):
    print "in start"
    time.sleep(self.times)


  def stop(self):
   self._bOn = False
   print "in stop"

log.py contains a class log with constructor that takes argument for time and sets the bOn variable to True.
start() - starts printing "in start" till the time bOn is True.
stop() - prints "in stop" when it is called. It would also stop the start() function as bOn is set to False now.

Now on to the parent script that would call log.py to run in thread.
"Main.py"
----------
import os
import log
import time
import thread

obj = log.log(5)

def startlog():
 print "in thread"
 obj.start()

thread.start_new_thread(startlog,())
time.sleep(11)
obj.stop()

Main.py, imports log.py with constructor argument as "5".
startlog() - prints "in thread" and then would call start() of log.py
startlog() is now run as a thread
Main script sleeps for 11 seconds and then
calls the stop() of log.py

Explanation:
In this example, when Main.py starts running, it imports log.py and sets the argument(time) of the constructor to 5. It then starts a thread for the function startlog() and goes to sleep for 11 seconds.
Now that a thread has started with startlog() function, it prints "in thread", then calls start() of log.py. Now that bOn is True, it prints "in start" and sleeps for 5 seconds as set by Main.py. After 5 seonds again it prints "in start".
During this time the Main.py is still sleeping. When 11 seconds pass by, Main.py comes out of sleep (log.py is still running though) and calls the stop() of log.py. Because of which, start() gets stopped as bOn is now set to False and it prints "in stop".
Thus we have seen, Main.py and log.py both ran in parallel and Main.py could control the execution of log.py as it was run in thread.

C++: Get Function Name inside the Function

Problem Statement:
Recently I faced a problem in C++ where I wanted to know the name of the function inside the function that was being called...Confused?! I meant, if I am writing the definition of function named Func(), I want to know the name "Func" inside the function.

Solution:
Solution is the use of printf("%s", __FUNCTION__);
The attribute __FUNCTION__ contains the name of the function which is being executed.
This is what we needed, isn't it?

Hope this helps!