MRTG with Nagios

Creating a file based logging script

2010-09-22T04:56:00.000-07:00

In this tutorial I will show you how you can create a small and simple PHP script to log your visitors activity into a file. You just need to add 1 line to each of your page to enable logging and the statistics will be collected in a html file so you don't have to setup any database for this task.

Step 1.
A basic logging script need to log visitors information in an easy and well-arranged format. In general the site owner want to know which pages of his/her site were visited most often, what source was the referrer and so on.

In this tutorial we will collect the following information about the visitor:

Visiting date
Visitor IP
Visitor hostname
Visitor browser type
The visited page
The referrer to the page

From this information you can the site owner can make any decision how to improve the site.

Step 2.
Now it's time to make some coding as well. To get the visitors IP, browser, referrer and visited page we can use the PHP built in super global variable the $_SERVER. From this array we can read out the above mentioned properties and their values.

So the code is the following:

php
    $userAgent = ( isset($_SERVER['HTTP_USER_AGENT'])
                     && ($_SERVER['HTTP_USER_AGENT'] != ""))
                 ? $_SERVER['HTTP_USER_AGENT'] : "Unknown";

    $userIp    = ( isset($_SERVER['REMOTE_ADDR'])
                      && ($_SERVER['REMOTE_ADDR'] != ""))
                  ? $_SERVER['REMOTE_ADDR']     : "Unknown";

    $refferer  = ( isset($_SERVER['HTTP_REFERER'])
                     && ($_SERVER['HTTP_REFERER'] != ""))
                 ? $_SERVER['HTTP_REFERER']    : "Unknown";

    $uri       = ( isset($_SERVER['REQUEST_URI'])
                      && ($_SERVER['REQUEST_URI'] != ""))
                  ? $_SERVER['REQUEST_URI']     : "Unknown";
?>

Explanation:
The $_SERVER array key definition are the following:

HTTP_USER_AGENT : Contents of the User-Agent: header from the current request, if there is one. This is a string denoting the user agent being which is accessing the page. A typical example is: Mozilla/4.5 [en] (X11; U; Linux 2.2.9 i586).

REMOTE_ADDR: The IP address from which the user is viewing the current page.

HTTP_REFERER: The address of the page (if any) which referred the user agent to the current page. This is set by the user agent. Not all user agents will set this, and some provide the ability to modify HTTP_REFERER as a feature. In short, it cannot really be trusted.

REQUEST_URI: The URI which was given in order to access this page; for instance, '/index.html'.

So we try to read this information if the actual properties doesn't exists or empty than we set it to 'Unknown'.

To get the hostname from the userIp I use the PHP built in function gethostbyaddr() which gets the Internet host name corresponding to a given IP address. Besides this getting the actual date is quite easy by using the date() function with a predefined date format string.

This part of the code looks like this:

php
    define("DATE_FORMAT","d-m-Y H:i:s");

    $hostName   = gethostbyaddr($userIp);
    $actualTime = date(DATE_FORMAT);?>

Step 3.
Now as we have the all of the visitors information so we need to store it in a file. To make it easier to read the file I will surround the data with a HTML table elements. As result when you open the log file you will get all of the information in a nice formatted HTML table.

The code which composes a log entry looks like this:

php
    $logEntry = "
        $actualTime
        $userIp
        $hostName
        $userAgent
        $uri
        $refferer
    \n";?>

Now we have to make some file handling. First of all we need to check whether the log file exists or not. If the file not exists yet than we will create a new one and write some HTML header information at the beginning. If the file already exists than we open it to append a new log entry.
After it we can write the log entry to the file and close it afterwards. That's all. As the file is a html file you can easy open/display it.

The complete logger coode looks like this:

php
    define("DATE_FORMAT","d-m-Y H:i:s");
    define("LOG_FILE","visitors.html");

    $logfileHeader='

    $userAgent = ( isset($_SERVER['HTTP_USER_AGENT'])
                     && ($_SERVER['HTTP_USER_AGENT'] != ""))
                 ? $_SERVER['HTTP_USER_AGENT'] : "Unknown";

    $userIp    = ( isset($_SERVER['REMOTE_ADDR'])
                      && ($_SERVER['REMOTE_ADDR'] != ""))
                  ? $_SERVER['REMOTE_ADDR']     : "Unknown";

    $refferer  = ( isset($_SERVER['HTTP_REFERER'])
                     && ($_SERVER['HTTP_REFERER'] != ""))
                 ? $_SERVER['HTTP_REFERER']    : "Unknown";

    $uri       = ( isset($_SERVER['REQUEST_URI'])
                      && ($_SERVER['REQUEST_URI'] != ""))
                  ? $_SERVER['REQUEST_URI']     : "Unknown";

    $hostName   = gethostbyaddr($userIp);
    $actualTime = date(DATE_FORMAT);

    $logEntry = "$actualTime$userIp$hostName$userAgent$uri$refferer\n";

    if (!file_exists(LOG_FILE)) {
        $logFile = fopen(LOG_FILE,"w");
        fwrite($logFile, $logfileHeader);
    }
    else {
        $logFile = fopen(LOG_FILE,"a");
    }

    fwrite($logFile,$logEntry);
    fclose($logFile);?>

Step 4.
Using the logger script is quite easy. Each of your page you want to log you need to add a new line: require_once("logger.php");
If the page is not a Php page than you need to rename it from html to Php or tell the Php to interpret the *.html pages as well.

So an example file looks like this:

php
    require_once("logger.php");

    echo "

This is an example page to show you how to use logger.

";
echo "Just insert the following code into your files:
";
echo 'require_once("logger.php");';?>

Introduction To Xajax

2010-09-13T03:25:00.000-07:00

Abstract

The Xajax class has come far in its progress and now the API has stabilized it is ready for work. This tutorial brings the absolute basics to get started with Xajax.

Hello World

Like all things, starting at the beginning is best. This script provides the absolute basics to getting Xajax working. The process is quite simply when broken down into smaller chunks. Like any PHP library, the class definition needs to be included. With xajax it is the xajax.inc.php bootstrap file that loads up the xajax environment and makes ready the ajax processes internally.
Xajax generates javascript code and provides a bridge, or callback, to PHP functions. To let Xajax know which functions are to be called, they must first be registered. The simple API of Xajax provides a register() function for this task. In the example below, the showText PHP function is registered.
When the register function is called, the returned object can be used to set parameters. In this example, the object is assigned to a variable named $rqstButton which is used later in the HTML to gene rate the onclick event code.
With the function registered, the requested function can be processed. This means the javascript for required to make a callback to PHP is generated internally and is ready to be retrieved with either the printJavascript() or getJavascript() methods.
The printJavascript() method, as the name suggests, just prints the javascript. However, a little more separation is nice, so the generated javascript can be assigned to a variable with the getJavascript() method. In these examples, the getJavascript() method is used to provide an level of separation between the HTML display code, and the PHP logic.

In the HTML, a simple echo statement is used to display the javascript generated by xajax. A little further down a call is made with javascript onClick event. The value for the onClick event is held in the rqstButton object and is simply echoed and that is really about all the javascript knowledge needed to get started, Xajax will do the rest.
But what of the showText() function itself? This function now becomes the engine room for the process. The content is contain in this function, however, in larger applications, the data may be sourced from external resources such as a database or file. A new response object is created, which will contain the information needed by xajax to perform the required actions. Again, the simple API provides a method to assign the content contained in the $content variable, to the innerHTML property of the target div named "my_div". The object response is returned and the task is complete.

 

    /*** include the xajax bootstrap ***/

    include 'xajax/xajax_core/xajax.inc.php';



    /*** a new xajax object ***/

    $xajax = new xajax();



    /*** register a PHP function with xajax ***/

    $rqstButton = $xajax->register(XAJAX_FUNCTION, 'showText');



    /*** set the request button parameters ***/

    $rqstButton->setParameter(0, XAJAX_JS_VALUE, 0);



    /*** process the request ***/

    $xajax->processRequest();





    function showText()

    {

        /*** the content to assign to the target div ***/

            $content = 'Hello World';



        /*** a new response object ***/

        $objResponse = new xajaxResponse();



        /*** assign the innerHTML attribute to the new $content ***/

        $objResponse->assign("my_div","innerHTML", $content);



        /*** return the object response ***/

        return $objResponse;

    }



    /*** process the request ***/

    $xajax->processRequest();



    /*** the path is relative to the web root mmmk ***/

    $xajax_js = $xajax->getJavascript('/xajax');?>











PHPRO.ORG

echo $xajax_js; ?>





->printScript(); ?>">Click me

New text will happen here

Manually Calling Requests

In the above code, the javascript to create the onClick event was generated by an object returned by the register() function. While the registration of the function needs to occur, the assigning of the variable does not, and the call could be made manually in the HTML document.

 



    /*** include the xajax bootstrap ***/

    include 'xajax/xajax_core/xajax.inc.php';



    /*** a new xajax object ***/

    $xajax = new xajax();



    /*** register a PHP function with xajax ***/

    $xajax->register(XAJAX_FUNCTION, 'showText');



    /*** process the request ***/

    $xajax->processRequest();





    function showText()

    {

        /*** the content to assign to the target div ***/

        $content = 'Hello World';



        /*** a new response object ***/

        $objResponse = new xajaxResponse();



        /*** assign the innerHTML attribute to the new $content ***/

        $objResponse->assign("my_div","innerHTML", $content);



        /*** return the object response ***/

        return $objResponse;

    }



    /*** process the request ***/

    $xajax->processRequest();



    /*** the path is relative to the web root mmmk ***/

    $xajax_js = $xajax->getJavascript('/xajax');?>











PHPRO.ORG

echo $xajax_js; ?>





Click me

New text will happen here

Debugging

Perhaps the most important functionality in the Xajax library is the debug option. When set, the debug option sends a print-out of the whole request process. This will prove invaluable when a script is not behaving as expected.
The debug flag is set, in most instances, immediately after the xajax object is instantiated. This means it will look a little like this.

 



    /*** include the xajax bootstrap ***/

    include 'xajax/xajax_core/xajax.inc.php';



    /*** a new xajax object ***/

    $xajax = new xajax();



    /*** set the debug flag ***/

    $xajax->setFlag('debug', true);



    /*** rest of script follows ... ***/

?>

PHP Class functions

2010-09-13T03:19:00.000-07:00

PHP Class functions

PHP has available several class functions to help you through the OOP mine field.

get_declared_interfaces()
class_exists()
get_class()
get_declared_classes()

Each of these is shown here beginning with the get_declared_interfaces().

get_declared_interfaces()

This helper function provides an array of all the available declared interfaces.

 

interface fax{

  public function dial();

  public function send();

  public function recieve();

}



interface printer{

  public function printBlack();

  public function printColor();

  public function printDraft();

  public function kick();

}

/*** our interface implementation ***/class printerFax implements fax, printer{

  public function dial(){ }

  public function send(){ }

  public function recieve(){ }

  public function printBlack(){ }

  public function printColor(){ }

  public function printDraft(){ }

  public function kick(){ }

}



  /*** create and printerfax object ***/

  $object = new printerFax;

  /*** get the declared interfaces ***/

  foreach(get_declared_interfaces() as $key=>$interface)

        {

        echo $key.' => '.$interface.'';

        }?>

The above code should produce a list such as this:

0 => Traversable
1 => IteratorAggregate
2 => Iterator
3 => ArrayAccess
4 => Serializable
5 => RecursiveIterator
6 => OuterIterator
7 => SeekableIterator
8 => Countable
9 => SplObserver
10 => SplSubject
11 => Reflector
12 => fax
13 => printer

From the list above you can see the SPL interfaces available and at the bottom is our fax and printer interfaces. The printerfax is not listed as it is not an interface, rather it is an implentation of an interface.

Other functions

Here we will see three helper functions for our classes

get_class()
class_exists()
get_declared_classes

 

/*** a pretend class ***/class fax{

  public function dial(){ }

  public function send(){ }

  public function recieve(){ }

}

/*** another pretend class ***/class printer{

  public function printBlack(){ }

  public function printColor(){ }

  public function printDraft(){ }

  public function kick(){ }

}

/*** create an instance of the fax class ***/$foo = new fax;

/*** create an instance of the printer class ***/$bar = new printer;



echo '$foo is from the ' get_class($foo).' class';

echo class_exists("printer").'';

echo 'Declared classes are: ';

foreach(get_declared_classes() as $key=>$classname)

    {

    echo $key.' -> '.$classname.'';

    }?>

The little snippet above will produce over one hundred available classes, shortened here for the sake of sanity, such as these below. Note our fax and printer classes at the bottom of the list.

$foo is from the fax class
1
0 -> stdClass
1 -> Exception
---8<--- snip ---
106 -> fax
107 -> printer

Autoload

Earlier in this tutorial we stated that the class definition must be included in every call to an object. This is commonly achieved with the include() or require() functions such as below.

 



/*** include our class definitions ***/include('classes/vehicle.class.php');



include('classes/motorcycle.class.php');



include('classes/printer.class.php');



include('classes/printer.class.php');

/*** instantiate a new vehicle class object ***/$vehicle = new vehicle;



*** instantiate a new motorcycle class object ***/$bike = new motorcycle;



*** instantiate a new printer class object ***/$printer = new printer;



*** instantiate a new fax class object ***/$fax = new fax;

?>

As you can see, this is quite cumbersome. The solution to this sort of mess is __autoload(). The __autoload() function will internally search out the class and load its definition. So the above block of code could be reduced to this.

 

/*** Autoload class files ***/function __autoload($class){

  require('classes/' . strtolower($class) . '.class.php');

}

/*** instantiate a new vehicle class object ***/$vehicle = new vehicle;

/*** instantiate a new motorcycle class object ***/$bike = new motorcycle;

/*** instantiate a new printer class object ***/$printer = new printer;

/*** instantiate a new fax class object ***/$fax = new fax;

?>

Now we can load up as many class definitions as we like because they will be autoloaded when we try to use a class that has not been defined. This can save much coding and much searching for code. It is important to remember the naming convention of your classes and class files. Each class file should be named the same as the class definition itself. eg: a class definition file named fax would have the filename fax.class.php
The use of the strtolower() function assures compatibility of naming conventions as windows machines fail to be case sensitive for filenames.

Serializing Objects

We have seen a lot of code above for the use of objects and how they can save us time (and $$$) by re-using them. But what if we needed to somehow store an object for later retrieval, perhaps in a database or in a session variable? PHP has given us the serialize() function to make this rather effortless. There are some limitations, but this can be a very useful tool for applications. Lets see how it performs with a little code.

 

/*** code here ***/?>

Overloading

Comes a time in every programmers life when...hmm
Overloading in PHP has caused much confusion for no real reason. PHP Overloading can be broken downinto two basic components

Method overloading
Property overloading

Simply put, Method Overloading is achieved by a special function named __call(). It is available as a sort of method wildcard for calls to undefined methods within a class. This special function is only called when the original method name does not exist. The __call() will only work when the class method you are trying to access does not exist. Lets take it for a spin..

 

class my_class{

 public function foo() {

    return "This is the foo function";

 }



} /*** end of class ***/



/*** create a new class object ***/$obj = new my_class;/*** call a non-existant method ***/$obj->bar();?>

Of course the above snippet of code will produce an error such as
Fatal error: Call to undefined method my_class::bar() in /www/overload.php on line 12
because we have called the bar() class method that does not exist. Enter __call(). With the __call() function in place, PHP will try to create the function and you have any code within the _call() method that you like. The __call() method takes two arguements, the method name, and the arguements. Your call to the undefined method may have many arguements and these are returned in an array. Lets put it to the test with two args.

 



class my_class{

 public function foo() {

    return "This is the foo function";

 }

  /*** __call() method with two args ***/

  public function __call($method, $arg){

   echo $method.'';

   print_r($arg);

 }

} /*** end of class ***/



/*** create a new class object ***/$obj = new my_class;/*** call a non-existant method ***/$obj->bar("arg1", "arg2");?>

The above code will print the following
bar
Array ( [0] => arg1 [1] => arg2 ) The __call() method has returned the method name that we called along with the array of args passed to it.
Lets now look at we can dynimically manipulate or overload our data.

 



class readyGetSet {/*** declare $item ***/private $item = 'Skate Board';/*** declare the price ***/private $price = 100;

/*** our call function ***/function __call($method, $arguments){/*** set property and prefix ***/

 $prefix   = strtolower(substr($method, 0, 3));

 $property = strtolower(substr($method, 3));



 if (empty($prefix) || empty($property))

        {

        return;

        }



if ($prefix == 'get' && isset($this->$property))

        {

        return $this->$property;

        }



if ($prefix == 'set')

        {

        $this->$property = $arguments[0];

        }

    }

}

$obj = new readyGetSet;



echo 'Item: ' . $obj->getItem() . '';

echo 'Price: ' . $obj->getPrice() . '';

$obj->setItem('CD');$obj->setPrice(25);



echo 'Item: ' . $obj->getItem() . '';

echo 'Price: ' . $obj->getPrice() . '';?>

The second part of overloading refers to properties and the ability to be able to dynamically get and set object properties. The __get() function is called when reading the value of an undefined property, and __set() is called when trying to change that properties value. I hope this is clear as it can get a little confusing... Lets see how it works by example.

 



 class candy{

 /*** declare a property ***/

 public $type='chocolate';



 /*** a normal method ***/

 public function wrap(){

   echo 'Its a wrap';

 }

 /*** our __set() function ***/

 public function __set($index, $value){

  echo 'The value of '.$index.' is '.$value;

 }



} /*** end of class ***/



/*** a new candy object ***/$candy = new candy;/*** set a non existant property ***/$candy->bar = 'Blue Smarties';

?>

The result from above will be:
The value of bar is Blue Smarties
Lets see what we have done. We have described a class named candy which contains a public property named $type. It has a simple method and our __set() method. After the class our user code creates a new instance of the candy class. Then we try to set a variable that does not exist in the class. Here the __set method takes control and assigns it for us. We then see in our __set method that it echoes the name of the variable, plus its intended value. The __set() method takes two arguements, the name of the non existant variable, and its intended value.

The __get() method ....

 





 class candy{

 /*** declare a property ***/

 public $type='chocolate';



 public $choctype = array('milk'=>0, 'dark'=>1, 'plain'=>2);



 /*** a normal method ***/

 public function wrap(){

   echo 'Its a wrap';

 }

 /*** our __set() function ***/

 public function __get($index){

    echo 'Retrieving element of $choctype property with index of '.$index.'';

     return $this->choctype[$index];

 }



} /*** end of class ***/



/*** a new candy object ***/$candy = new candy;/*** set a non existant property ***/

 echo 'The value of the following element property is '.$candy->milk;

?>

From the above code we get the result
Retrieving element of $choctype property with index of milk
The value of the following element property is 0

Class Constants

You have more than likely seen the use standard constants in PHP. To define a standard constant we use this code:

 

/*** define an error message ***/

define('_ERROR_MSG', 'An Error has occured!');

/*** echo the constant ***/

echo _ERROR_MSG;

?>

The above snippit would output
An Error has occured!
To define a class constant we use the const keyword.

 



class my_class {

 /*** define a class constant ***/

 const _ERROR_MSG = 'An Error has occured!';



public function show(){

 echo self::_ERROR_MSG;

}



} /*** end of class ***/?>

There are now three ways the class constant can be access from this example.

 /*** static call to constant ***/echo my_class::_ERROR_MSG;/*** instantiate a class object ***/$my_class = new my_class;/*** can run the show() method ***/$my_class->show();/*** static call to the show method() ***/my_class::show();?>

Each of the above methods would output the same line
An Error has occured!
A class constant, like standard constants, must be exactly as the name suggests, a constant value. It cannot be a variable or the result of a function or method.

Credits

This concludes our little insight into PHP OOP. If you have anything you would like to see here just contact us and we will do our best to help.

PHP - Visibility (public, private, protected)

2010-09-13T03:16:00.000-07:00

Visibility (public, private, protected)

The visibility of class members, (properties, methods), relates to how that member may be manipulated within, or from outside the class. Three levels of visibilty exist for class members.

public
private
protected

By default, all class members are public. This means if you do not declare a property or method within the class, it will be public. It is good practice to declare the visibility of class members for the sake of readability for yourself and others. It is much easier for another programmer to see your intentions. This will also future proof your scripts should access modifiers be deprecated.
Public class members (properties and methods) are available through-out the script and may be accessed from outside the class as we demonstrated in our car class. Lets create a simple new class to demonstrate.

 



class mathematics{/*** a  number ***/public $num;

/**

*

* Add two to a number

*

* @access public

*

* @return int

*

**/public function addTwo(){

  return $this->num+2;

}



}/*** end of class ***/



/*** Instantiate a new class instance ***/$math = new mathematics;

/*** set the value of the number ***/$math->num = 2;

/*** call the addTwo method ***/echo $math->addTwo();

?>

We can see in the above example that the public variable $num is set from user space and we call a public method that adds two the number and returns the value of $num+2. Having our properties (variables) visible, or accessible from any part of our script works in our favour here, but it can also work against us. A could arise if we lost track of our values and changed the value of $num. To counter this problem we can create a method to set the value for us. Even with this in place it is still possible for somebody to simply access the $num variable. So we make the variable private. This ensures us that the property is only available within the class itself. It is private to the calling class. Consider the following code.

 





class mathematics{

/*** a  number ***/private $num;

/**

*

* Set the value of $num

*

* @access public

*

* @param $num The number to set

*

* @return int

*

**/public function setNum($num){

  $this->num = $num;

}

/**

*

* Add two to a number

*

* @access public

*

* @return int

*

**/public function addTwo(){

  return $this->num+2;

}



}/*** end of class ***/



/*** Instantiate a new class instance ***/$math = new mathematics;

/*** set the value of the number ***/$math->setNum(2);

/*** call the addTwo method ***/echo $math->addTwo();

?>

?>

Any further attempt to reset the $num property without the setNum() method would result in a Fatal Error such as
Fatal error: Cannot access private property mathematics::$num in /www/mathematics.class.php on line 43
Even if you were to try to access the private $num property from a child class it would fail. This is because private methods and properties in a parent class are not visible to child classes and cannot be accessed. To access a parent method or property from a child class you need to use the protected keyword. Like the private keyword, protetected methods and properties are available only to the class that created them. But unlike private, protected methods and properties are visible from a parent class. Lets see how this works.

 

class mathematics{/*** a  number ***/protected $num;

/**

*

* Set the value of $num

*

* @access public

*

* @param $num The number to set

*

* @return int

*

**/public function setNum($num){

  $this->num = $num;

}

/**

*

* Add two to a number

*

* @access public

*

* @return int

*

**/public function addTwo(){

  return $this->num+2;

}



}/*** end of class ***/

class divide extends mathematics{

/**

*

* Divide a number by two

*

* @access public

*

* @return int

*

**/public function divideByTwo(){

  /*** divide number by two ***/

  $new_num = $this->num/2;

  /*** return the new number and round to 2 decimal places ***/

  return round($new_num, 2);

}



} /*** end of class ***/



/*** Instantiate a new class instance ***/$math = new divide;

/*** set the value of the number ***/$math->setNum(14);



echo $math->divideByTwo();

?>

We can see here the the user space code has called the setNum() method in the parent mathematics class. This method, in turn, sets the $num property. We are able to do this because the $num property has been declared protected and is visible to the child class.

Final

As we saw in the previous section there are ways to protect your code from being used in an improper manner. Another way of protecting yourself is the Final keyword. Any method or class that is declared as Final cannot be overridden or inherited by another class. Lets put it to the test.

 

final class mathematics{



} /*** end of class ***/

class divide extends mathematics{



}

?>

By running the above code you will get an error such as
Fatal error: Class divide may not inherit from final class (mathematics) in /www/final.php on line 8
This can protect us from those who wish to use our code for a purpose other than that for which it was intended.

Abstract Classes

An abstract class is a class that cannot be instantiated on its own. You cannot create a new object from it. To see this lets make a basic class.

 

abstract class mathematics{

/**

*

* Add two to a number

*

* @access public

*

* @return int

*

**/public function addTwo(){

  return $this->num+2;

}



} /*** end of class ***/



/*** try to create new object from the mathematics class ***/$math = new mathematics



?>

Using the code above, you will get an error something like this
Fatal error: Cannot instantiate abstract class mathematics in /www/abstract.php on line 23.
As you can see, this is not allowed. Also if you declare any class method to be abstract, you must also declare the class itself as abstract too. So, whats the point you ask? Well, you can inherit from an abstract class. Any class that extends an abstract parent class must create an interface of the parent abstract methods. If this is not done a fatal error is generated. This ensures that the implementation is correct.

 

abstract class mathematics{/*** child class must define these methods ***/abstract protected function getMessage();



abstract protected function addTwo($num1);

/**

*

* method common to both classes

*

**/public function showMessage() {

  echo $this->getMessage();

}



} /*** end of class ***/

class myMath extends mathematics{/**

*

* Prefix to the answer

*

* @return string

*

**/protected function getMessage(){

  return "The anwser is: ";

}

/**

*

* add two to a number

*

* @access public

*

* @param $num1 A number to be added to

*

* @return int

*

**/public function addTwo($num1) {

  return $num1+2;

}



} /*** end of class ***/



/*** a new instance of myMath ***/$myMath = new myMath;/*** show the message ***/$myMath->showMessage();/*** do the math ***/echo $myMath->addTwo(4);

?>

Static Methods and Properties

The use of the static keyword allows class members (methods and properties) to be used without needing to instantiate a new instance of the class. The static declaratin must come after the visibility declaration, eg:
public static myClass{
Because there is no object created when using a static call, the keyword $this and the arrow operator, -> are not available. Static variables belong to the class itself and not to any object of that class. To access withing the class itself you need to use the self keyword along with the :: scope resolution operator. Lets whip up a quick example of using static.

 /*** a simple class ***/class myClass{/*** a static variable ***/ static $foo;

}

/** give the static variable a value ***/myClass::$foo = 'Bar';

/*** echo the static variable ***/echo (myClass::$foo ).?>

The above snippet will echo
Bar This is rather basic as an example, so lets use something practical. Static properties are often used as counters. Here we will use a basic counter class.

 class counter{

/*** our count variable ***/private static $count = 0;

/**

* Constructor, duh

**/function __construct() {

  self::$count++;

}

/**

*

* get the current count

*

* @access public

*

* @return int

*

**/public static function getCount() {

 return self::$count;

}



} /*** end of class ***/



/*** create a new instance ***/$count = new counter(); /*** get the count ***/echo counter::getCount() . '';/*** create another instance ***/$next = new counter(); /*** echo the new count ***/echo counter::getCount().''; /*** and a third instance ***/$third = new counter;

echo counter::getCount().'';?>

Hopefully by the end of the above snippet you can see what is happening. At each new instance the counter class we increment by one. Not also the use of the :: scope resolution operator and self keyword to refer to the static variable within the class itself.

Interfaces

Interfaces in PHP allow you to define a common structure for your classes. An interface cannot be instantiated on its own. One of the goals of OOP is re-use of code. Interfaces make this a much easier process. The interface methods have no internal logic, they are simply a "mapping" or constraint of what the class, or classes, should implement. Here we will demonstrate how this works using our vehicle class from earlier, with the addition of a stop() function.

 class vehicle implements testdrive{

/*** define public properties ***/



/*** the color of the vehicle ***/public $color;

/*** the number of doors ***/public $num_doors;

/*** the price of the vehicle ***/public $price;

/*** the shape of the vehicle ***/public $shape;

/*** the brand of vehicle ***/public $brand;

/*** the constructor ***/public function __construct(){

  echo 'About this Vehicle.';

}

/*** define some public methods ***/



/*** a method to show the vehicle price ***/public function showPrice(){

  echo 'This vehicle costs '.$this->price.'.';

}

/*** a method to show the number of doors ***/public function numDoors(){

  echo 'This vehicle has '.$this->num_doors.' doors.';

}

/*** method to drive the vehicle ***/public function drive(){

  echo 'VRRROOOOOOM!!!';

}/**

* a method to stop the car

*

* @access public

*

**/public function stop(){

  echo 'SSSCCRRREEEEEECCHH!!!';

}



} /*** end of class ***/



/*** declare our interface ***/interface testdrive{/*** some functions that must be implemented ***/function drive();

function stop();

}

/*** an new vehicle object ***/$object = new vehicle;

/*** call some methods ***/$object->drive();$object->stop();?>

You may of course create multiple classes to implement your interface, but they will not inherit from each other. When you inherit from a parent class, you may choose to override some of parent methods. If you had multiple parent class methods with the same name, but different functionality or charactaristics, PHP would have no way of telling which of these methods to use. This is why multiple inheritance does not work in PHP. In contrast, classes that implement an interface, must implement every method so there is no ambiguity.
In the real world interfaces provide us with the tools harness parts of multiple classes. Consider this scenario. If we had two classes, one for a fax and the other for a printer. Each has seperate uses and could be described like this:

 

class fax{

  public function dial();

  public function send();

  public function recieve();

}



class printer{

  public function printBlack();

  public function printColor();

  public function printDraft();

}?>

Both of the above classes give the required usage for each item, but they do not take into consideration the existance of a printer/fax machine. To get the usage of both classes we would do something like this:

 

class fax{

  public function dial();

  public function send();

  public function recieve();

}



class printer extends fax{

  public function printBlack();

  public function printColor();

  public function printDraft();

  public function kick();

}



class printerFax extends fax{

}

$object = new printerFax;?>

This code works by creating a stack of classes. The grandparent class is fax. Then the printer class extends the fax class and inherits all the methods from that class. This is where some problems may arise. The printer class now has the function dial() available to it which is clearly going to cause some confusion and possibly errors in logic.
To counter this problem an interface can be used to tell the classes what functions (methods) are required. Lets look at the design.

 

interface fax{

  public function dial();

  public function send();

  public function recieve();

}



interface printer{

  public function printBlack();

  public function printColor();

  public function printDraft();

  public function kick();

}



class printerFax implements fax, printer{

  public function dial(){ }

  public function send(){ }

  public function recieve(){ }

  public function printBlack(){ }

  public function printColor(){ }

  public function printDraft(){ }

  public function kick(){ }

}



  $object = new printerFax;?>

Before we go further, it is recommended you run the above code. It will produce no output but we need to be sure all is well. Having run the code, remove the line
public function kick(){ }
and run it again. What you should now get is an error such as:
Fatal error: Class printerFax contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (printer::kick) in /www/oop.php on line 22
With the kick() function removed from our implementation, we have essentially broken the contract that says we will implement every function (method) specified in the interface. We can gather these functions fractionally from multiple classes, but we MUST have them all or we will get errors such as the one above.
Interfaces play a major role in with SPL and it is recommend you implement the interfaces from SPL and not just the class methods.

PHP 5 with OOPs

2010-09-13T03:12:00.000-07:00

What is OOP

OOP was first invented for the purpose of physical modelling in the Simula-67.
Whilst there is no hard and fast definition of what Object Oriented Programming (OOP) is, we can define. So lets just use this loose definition for now and it is left to reader to make up their own minds about what a decent definition is. Object Oriented Programming (OOP) is a programming concept that treats functions and data as objects. OK, not the best definition but gives us an opening. The key word here is objects. As we progress through this tutorial we will see how data and functions can be represented as re-usable objects, thus cutting down on code and time.

What is an Object

Simply put, an oject is a bunch of variables and functions all lumped into a single entity. The object can then be called rather than calling the variables or functions themselves. Within an object there are methods and properties. The methods are functions that manipulate data withing the object. The properties are variables that hold information about the object.

What is a Class

A class is the blueprint for your object. The class contains the methods and properties, or the charactaristics of the object. It defines the object. Lets just start with some examples to see how it all pieces together. We will use a vehicle as our object. All vehicles share similar charactaristics, eg: number of doors, they are painted some color, they each have a price. All vehicles do similar things also, drive, turn left, turn right, stop etc. These can be described as functions, or in OOP parlance, methods. So, the class holds the definition, and the object holds the value. You declare class in PHP by using the class keyword.

class vehicle{/*** define public properties ***/



/*** the color of the vehicle ***/public $color;

/*** the number of doors ***/public $num_doors;

/*** the price of the vehicle ***/public $price;

/*** the shape of the vehicle ***/public $shape;

/*** the brand of vehicle ***/public $brand;

/*** the constructor ***/public function __construct(){

  echo 'About this Vehicle.';

}

/*** define some public methods ***/



/*** a method to show the vehicle price ***/public function showPrice(){

  echo 'This vehicle costs '.$this->price.'.';

}

/*** a method to show the number of doors ***/public function numDoors(){

  echo 'This vehicle has '.$this->num_doors.' doors.';

}

/*** method to drive the vehicle ***/public function drive(){

  echo 'VRRROOOOOOM!!!';

}



} /*** end of class ***/?>

With this simple class definition we can now create one, or many, vehicle objects. Lets see how its done, then we will step through it all. To create a new object from the class definition we use the new keyword.

 

/*** create a new vehicle object ***/$vehicle = new vehicle;

/*** the brand of vehicle ***/$vehicle->brand = 'Porsche';

/*** the shape of vehicle ***/$vehicle->shape = 'Coupe';

/*** the color of the vehicle ***/$vehicle->color = 'Red';

/*** number of doors ***/$vehicle->num_doors = 2;

/*** cost of the vehicle ***/$vehicle->price = 100000;

/*** call the showPrice method ***/$vehicle->showPrice();

/*** call the numDoors method ***/$vehicle->numDoors();

/*** drive the vehicle ***/$vehicle->drive();

?>

Using the combination of the two code boxes above, you should have something like..
About this vehicle.
This vehicle costs 100000.
This vehicle has 2 doors.
Lets step through the class definition first to see what its all about.
We began the class with the class keyword. This tells PHP that what follows is a class definition.

 

class vehicle{

?>

Next we declared some variables, or as they are known in the OOP world, properties.

 

/*** the color of the vehicle ***/public $color;

/*** the number of doors ***/public $num_doors;

/*** the price of the vehicle ***/public $price;

/*** the shape of the vehicle ***/public $shape;

/*** the brand of vehicle ***/public $brand;

?>

The properties are the individual charactaristics of the vehicle object. The public declares that this property may be accessed within the public scope. This means you may set it from within your code. Next in the class definition is this code..

 

/*** the constructor ***/public function __construct(){

  echo 'About this vehicle.';

}?>

The constructor method (function) is a special function that is executed every time a new object is created or "instantiated". If a class needs to do something before running some code, then this is the place to do it. It is often used to set properties within the class. You may pass a variable directly to the constructor from your code, but more of that later. Following the constructor is several methods (functions) that do things. These methods are also preceded by the public meaning they are available with the scope of your code.

 

/*** a method to show the vehicle price ***/public function showPrice(){

  echo 'This vehicle costs '.$this->price.'.';

}

/*** a method to show the number of doors ***/public function numDoors(){

  echo 'This vehicle has '.$this->num_doors.' doors.';

}

/*** method to drive the vehicle ***/public function drive(){

  echo 'VRRROOOOOOM';

}

?>

As you see above, our methods are similar to normal PHP functions. However you may note the use of variables like $this->price and $this->num_doors. The keyword $this is used to refer to properties or methods within the class itself. The $this keyword is reserved in PHP, so it cannot be used as a variable or property name. Finally we finished our class definition with a closing }. I like to put a comment beside it so I dont delete it or get it confused with a function I am writing.
Following on from the class definition we see our userland code. This is the code we use to instantiate (create) a new instance, or new object, of our vehicle class. As mentioned earlier we do this with the use of the new keyword.

 

/*** create a new vehicle object ***/$vehicle = new vehicle;

?>

The code above creates a new object from our class definition called $vehicle. It is at this time that the constructor is called and any code within the constructor is executed. Once we have a new object we can then begin to assign values to the properties of that object as seen here.

 

/*** the brand of vehicle ***/$vehicle->brand = 'Porsche';

/*** the shape of vehicle ***/$vehicle->shape = 'Coupe';

/*** the color of the vehicle ***/$vehicle->color = 'Red';

/*** number of doors ***/$vehicle->num_doors = 2;

?>

With the properties set as above, it is now simple to use the object methods to manipulate the object by calling the methods. The methods are executed like this below.

 /*** call the showPrice method ***/$vehicle->showPrice();

/*** call the numDoors method ***/$vehicle->numDoors();

/*** drive the vehicle ***/$vehicle->drive();?>

So, thats the step-by-step of your first class. You see how easy it would be now to create a new car object. Perhaps a Red Ferrari with 4 doors costing $250,000.00.

Commenting Code

In the previous sections you have seen comments for almost every line of code. This is a good practice, although some may find it excessive, as it may not be you who has to edit the code next time. OOP can get very abstracted and if you are not careful it is easy to lose site of your programmatical work flow. Most methods within a class will return a value, rather than echo a line of HTML code. A class method may also take one, or several, arguements. It is good practice to show what these arguements are and there types. An example follows below.

   /**

  * adds an array of numbers and returns the value

  *

  * @param array $numbers An array of numbers to add

  *

  * @access private

  *

  * @return int Returns sum of numbers

  *

  */

  private function sum_of_numbers($numbers){

    /*** return the sum of the $numbers array ***/

    return array_sum($numbers);

  }?>

The above function is rather simplistic, but shows well the commenting of code. The comments begin in a block of C type multiline comments and gives us a brief description of what it does, followed by the parameter it takes, in this case an array of numbers. It tells us that access to the function is private (more on this in the next section). Finally the comment block tells us that the return value is of type INT. We can also see within the function itself a single line comment just to show what is happening within the funtion itself. If you follow these practices you code will always be readable and easy to follow by yourself and others.

Inheritance (Extending a class)

Probably the greatest feature of the PHP OOP model is Inheritence. Inheritence is the ability of php to extend classes (child classes) that inherit the charactaristics of the parent class. The resulting object of an extend class has all the charactaristics of the parent class, plus whatever is in the new child, or extended class. In this instance we will extend the vehicle class and add a motorcyle. A motorcycle is still a vehicle and shares many of the same attributes such as price, drive etc. But a motorcycle has some unique features that a car does not.
Rather than type out the whole of the vehicle class definition again, we will save it in a file of its own called vehicle.class.php. It is important here to note the naming convention here as it will be important later in this tutorial. Lets see how it works.

 





/*** include the vehicle class definition ***/include('vehicle.class.php');



class motorcycle extends vehicle{

/*** the number of side cars ***/private $num_sidecars;



private $handlebars;

/**

*

* set the type of handlebars

*

* @access public

*

* @param string

*

* @return string

*

**/public function setHandlebars($handlebarType){

  $this->handlebars=$handlebarType;

}

/**

*

* Set number of side cars

*

* @access public

*

* @param int

*

* @return int

*

**/public function setSidecar($numSidecars){

  $this->numSidecars = $numSidecars;

}



/**

*

* Show the numbers of sidecars

*

* @return string

*

**/public function showSideCar(){

  echo 'This motorcyle has '. $this->numSidecars.' sidecar';

}



} /*** end of class ***/





/*** our userland code ***/



/*** create a new vehicle object ***/$vehicle = new motorcycle;

/*** the brand of vehicle ***/$vehicle->brand = 'Harley Davidson';

/*** the shape of vehicle ***/$vehicle->shape = 'Sportster';

/*** the color of the vehicle ***/$vehicle->color = 'Black';

/*** number of doors ***/$vehicle->num_doors = 0;

/*** cost of the vehicle ***/$vehicle->price = 25000;

/*** type of handle bars ***/$vehicle->setHandlebars('Ape Hangers');

/*** set the sidecar ***/$vehicle->setSidecar(1);

/*** show the vehicle brand and type ***/echo $vehicle->brand.': '.$vehicle->shape.'';



/*** call the showPrice method ***/$vehicle->showPrice();

/*** show the sidecars ***/$vehicle->showSideCar();

/*** drive the vehicle ***/$vehicle->drive();

?>

You see in the motorcycle class that we have used the keyword extends to extend our vehicle class. We can then proceed to set vars in the both the parent class and the child class. The child class has inherited all the characaristics of the parent vehicle class.
If you run the above code with out including the parent class, you will get a Fatal Error like this:
Fatal error: Class 'vehicle' not found in /www/oop.php on line 3

You MUST include the class definition on every page when you store an object

This means when you use an object or wish to extend from it. you must include the class file. Either as code, or most commonly, with an include() statement.

New features in PHP 6

2010-09-08T23:26:00.000-07:00

As you may be aware the core PHP group of developers all met in Paris on November the 11th and 12th 2005. The minutes from the meeting are fascinating reading, but there is a lot to go through. So I've gone through all of the points raised and chewed them over from a developers point of view. Your comments as always are welcome.
Before I get started however I'd just like to make one thing very clear: what you read here (or in the original minutes) are in no way the 'fully 100% decided' end results / changes that we'll see in PHP6. They will most likely all be discussed further (on internals and wider), but even so we can take the information presented in the minutes as being the PHP teams most 'current' way of thinking about any given subject.

Unicode

Unicode support at present can be set on a per request basis. This equates to PHP having to store both Unicode and non-Unicode variants of class, method and function names in the symbol tables. In short - it uses up more resources. Their decision is to make the Unicode setting server wide, not request wide. Turning Unicode off where not required can help performance and they quote some string functions as being up to 300% slower and whole applications 25% slower as a result. The decision to move it to the php.ini in my mind does take the control away from the user, and puts it into the hands of the Web Host.
If you compile PHP yourself or are responsible for this on your servers then you may be interested to know that PHP 6 will require the ICU libs (regardless if Unicode is turned on or off). The build system will bail out if the required ICU libs cannot be found. In a nutshell, you'll have another thing to install if you want to compile PHP.

Register Globals to go

Say goodbye folks, this one is finally going. It will no longer be an ini file setting, and if found it will raise an E_CORE_ERROR, pointing you to the documentation on why it's "bad". This means that PHP6 will finally break all PHP3 era scripts (or any script using reg globals) with no recourse at all but to re-code it. That's a bold move, but a needed one.

Magic Quotes to go

The magic quotes feature of PHP will be going, and as with register globals it's going to raise an E_CORE_ERROR if the setting is found anywhere. This will affect magic_quotes, magic_quotes_sybase and magic_quotes_gpc.

Safe Mode to go

This may please developers who have web hosts that insist upon safe mode! But it will now go totally, again raising an E_CORE_ERROR if found. The reason is that apparently they felt it gave the 'wrong signal', implying that it made PHP secure, when infact it didn't at all. open_basedir will (thankfully) be kept.

'var' to alias 'public'

PHP4 used 'var' within classes. PHP5 (in its OO move) caused this to raise a warning under E_STRICT. This warning will be removed in PHP6 and instead 'var' will mean the same thing as 'public'. This is a nice move but I if anyone has updated their scripts to work under E_STRICT in PHP5 it will be a redundant one for them.

Return by Reference will error

Both '$foo =& new StdClass()' and 'function &foo' will now raise an E_STRICT error.

zend.ze1 compatbility mode to go

ze1 always tried to retain old PHP4 behaviour, but apparently it "doesn't work 100%" anyway, so it will be removed totally and throw an E_CORE_ERROR if detected.

Freetype 1 and GD 1 support to go

Support for both of these (very very old) libs will be removed.

dl() moves to SAPI only

Each SAPI will register the use of this function as required, only the CLI and embed SAPIs will do this from now on. It will not be available elsewhere.

FastCGI always on

The FastCGI code will be cleaned up and always enabled for the CGI SAPI, it will not be able to be disabled.

Register Long Arrays to go

Remember the HTTP_*_VARS globals from yesteryear? Well if you're not already using $_GET, $_POST, etc - start doing so now, because the option to enable long arrays is going (and will throw an E_CORE_ERROR).

Extension Movements

The XMLReader and XMLWriter extensions will move into the core distribution and will be on by default.
The ereg extension will move to PECL (and thus be removed from PHP). This means that PCRE will not be allowed to be disabled. This will make way for the new regular expression extension based on ICU.
The extremely useful Fileinfo exntesion will move into the core distribution and enabled by default.

PHP Engine Additions

64 bit integers
A new 64 bit integer will be added (int64). There will be no int32 (it is assumed unless you specify int64)
Goto
No 'goto' command will be added, but the break keyword will be extended with a static label - so you could do 'break foo' and it'll jump to the label foo: in your code.
ifsetor()
It looks like we won't be seeing this one, which is a shame. But instead the ?: operator will have the 'middle parameter' requirement dropped, which means you'd be able to do something like this: "$foo = $_GET['foo'] ?: 42;" (i.e. if foo is true, $foo will equal 42). This should save some code, but I personally don't think it is as 'readable' as ifsetor would have been.
foreach multi-dim arrays
This is a nice change - you'll be able to foreach through array lists, i.e. "foreach( $a as $k => list($a, $b))".
{} vs []
You can currently use both {} and [] to access string indexes. But the {} notation will raise an E_STRICT in PHP5.1 and will be gone totally in PHP6. Also the [] version will gain substr and array_slice functionality directly - so you could do "[2,]" to access characters 2 to the end, etc. Very handy.

OO changes

Static Binding
A new keyword will be created to allow for late static binding - static::static2(), this will perform runtime evaluation of statics.
Namespaces
It looks like this one is still undecided - if they do implement namespaces it will be using their style only. My advice? Don't hold your breath!
Type-hinted Return Values
Although they decided against allowing type-hinted properties (becaue it's "not the PHP way") they will add support for type-hinted return values, but have yet to decide on a syntax for this. Even so, it will be a nice addition.
Calling dynamic functions as static will E_FATAL
At the moment you can call both static and dynamic methods, whether they are static or not. Calling a dynamic function with the static call syntax will raise an E_FATAL.

Additions to PHP

APC to be in the core distribution
The opcode cache APC will be included in the core distribution of PHP as standard, it will not however be turned on by default (but having it there saves the compilation of yet another thing on your server, and web hosts are more likely to allow it to be enabled)
Hardened PHP patch
This patch implements a bunch of extra security checks in PHP. They went over it and the following changes will now take place within PHP: Protection against HTTP Response Splitting will be included. allow_url_fopen will be split into two: allow_url_fopen and allow_url_include. allow_url_fopen will be enabled by default. allow_url_include will be disabled by default.
E_STRICT merges into E_ALL
Wow, this is quite a serious one! E_STRICT level messages will be added to E_ALL by default. This shows a marked move by the PHP team to educate developers on 'best practises' and displaying language-level warnings in a "Hey, you're doing it the wrong way".
Farewell <%
They will remove support for the ASP style tags, but the PHP short-code tag will remain (

Conclusion

PHP6 is taking an interesting move in my mind - it's as if the PHP developers want to now educate developers about the right way to code something, and remove those lingering issues with "Well you SHOULD be doing it this way, but you can still do it the old way". This will not be the case any longer. Removing totally the likes of register globals, magic quotes, long arrays, {} string indexes and call-time-pass-by-references will force developers to clean up their code.
It will also break a crapload of scripts beyond repair that doesn't involve some serious re-writing. Is this a bad thing? I don't think so myself, but I see it making the adoption of PHP6 even slower than that of PHP5, which is a real shame. However they have to leap this hurdle at some point, and once they've done it progression to future versions should be swifter.

Add mrtg to nagios

2010-09-04T00:25:00.000-07:00

Mrtg software may install during initial installation; you can verify if MRTG installed or not with following RPM command:

rpm -qa | grep mrtg

If mrtg already installed please see

step # 5; else use rpmfind.net to find MRTG rpm or up2date command to install MRTG software:

# up2date -v -i mrtg

Fedora Linux user can use yum command as follows to install MRTG:

# yum install mrtg

Step # 5 : Commands to Configure mrtg

(a) Create document root to store mrtg graphs/html pages:
# mkdir -p /var/www/html/mymrtg/
(b) Run any one of the following cfgmaker command to create mrtg configuration file:
#cfgmaker --global 'WorkDir: /var/www/html/mymrtg' --output /etc/mrtg/mymrtg.cfg public@localhost
OR (make sure your FQDN resolves, in following example i'm using rh9.test.com which is my router FQDN address)
# cfgmaker --global 'WorkDir: /var/www/html/mymrtg' --output /etc/mrtg/mymrtg1.cfg public@rh9.test.com
(c) Create default index page for your MRTG configuration:
# indexmaker --output=/var/www/html/mymrtg/index.html /etc/mrtg/mymrtg.cfg
(d) Copy all tiny png files to your mrtg path:
# cp -av /var/www/html/mrtg/*.png /var/www/html/mymrtg/
Run mrtg command from command line with your configuration file:

# mrtg /etc/mrtg/mymrtg.cfg

Note: You may get few warning message for first time; ignore them.
(b) Fire your favorite web browser (like FireFox :D ) and type url http://www.your.com/mymrtg/ or http://your-ip/mymrtg/

******************************
Now Your MRTG is running fine. Integrate it to nagios
************************************
Procedure to monitor Bandwidth Usages in Nagios:

1. Default installation directory of nagios is /usr/local/nagios/.

2. Open switch.cfg file
vi /usr/local/nagios/etc/objects/switch.cfg

3. Make changes according to your router specifications. Like,
define host{
use generic-switch
host_name Router_1
alias Router 1
address 172.17.42.22
hostgroups switches
}
4. You can also set PING, Uptime, Ports Link Status etc.
define service{
use generic-service ; Inherit values from a template
host_name Router_1 ; The name of the host the service is associated with
service_description PING ; The service description
check_command check_ping!200.0,20%!600.0,60% ; The command used to monitor the service
normal_check_interval 5 ; Check the service every 5 minutes under normal conditions
retry_check_interval 1 ; Re-check the service every minute until its final/hard state is determined
}

define service{
use generic-service ; Inherit values from a template
host_name Router_1
service_description Uptime
check_command check_snmp!-C public -o sysUpTime.0 -H 172.17.42.22
}

define service{
use generic-service ; Inherit values from a template
host_name Router_1
service_description Port 2 Link Status
check_command check_snmp!-C public -o ifOperStatus.2 -r 1 -H 172.17.42.22
}

define service{
use generic-service ; Inherit values from a template
host_name Router_1
service_description Port 2 Bandwidth Usage
check_command check_local_mrtgtraf!/var/www/html/mrtg/172.17.42.22_2.log!AVG!1000000,1000000!5000000,5000000
!10
}

5. Verify the configuration of nagios
/usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg

6. Restart nagios service.
/etc/init.d/nagios restart

Install and Enable SNMP Service in Windows XP, Vista and 2003

2010-09-03T22:29:00.000-07:00

SNMP (Simple Network Management Protocol) is an internet protocol used in network management systems to monitor network-attached devices such as computers, servers, routers, switches, gateways, wireless access points, VoIP phones, and etc. for conditions that warrant administrative attention. SNMP provides management data in the form of variables on the managed systems, which describe the system configuration parameter or current status value. These variables can then be read and queried (or sometimes set or write) by managing applications. Windows system running XP, Vista or 2003 does not turn on SNMP service by default, thus users need to manually install and enable SNMP service.

Note that you must be logged on as an administrator or a member of the Administrators group in order to complete this procedure. If your computer is connected to a network, network policy settings may also prevent you from completing this procedure.

How to Install and Enable the SNMP Service

In Windows XP and Windows 2003, click Start button, then go to Control Panel and run Add or Remove Programs
applet. On Add or Remove Programs dialog, click Add/Remove Windows Components to open Windows Components wizard.
In Windows Vista, click Start button, then go to Control Panel. Click on Programs link and then click on Turn Windows features on or off. If you’re prompted with User Account Control dialog, click “Continue”.
In Components of Windows XP and 2003, click on the Management and Monitoring Tools (make sure that you do not select or clear, tick or untick its check box to change the existing selection), and then click Details.
In Windows Features of Vista, locate SNMP feature.
Select and tick the check box of Simple Network Management Protocol or SNMP feature.
Click OK. Also click Next if you’re in Windows XP or 2003. SNMP service will be installed on the system. You may require to insert the Windows setup CD/DVD disc into optical drive.
SNMP will start automatically after installation. But it’s recommended to verify the service status from Services in Control Panel, and if it’s stopped, you can start the SNMP service from there.
Two new services will be created:
1. SNMP Service which is the main engine with agents that monitor the activity in the network devices and report the information to the monitoring console workstation.
2. SNMP Trap Service which receives trap messages generated by local or remote SNMP agents and forwards the messages to SNMP management programs running on this computer.

Windows doesn’t assign any community string to the SNMP service by default, and also only allow access from localhost or local devices. Further configuration is needed to add in desired community string, which act as the password to grant reply to any SNMP request from remote system.

How to Configure SNMP Service (Add “public” community string)

Click on Start button, then go to Control Panel.
In Windows Vista, click on System and Maintenance link.
Open Adminstrative Tools.
Run Services applet.
Locate and right click on SNMP Service, then select Properties.
In SNMP Service Properties window, click on Traps tab.
In the “Community name” text box, enter public or any other case-sensitive SNMP community name to which this computer will send trap messages.
Click on Add to list button.

How to Configure Security for SNMP Service for a Community
Continue from above steps, click on Security tab. If you already close SNMP Service Properties window, re-open it.
Under “Accepted community names” section, click Add button.
Select the appropriate permission level for the community string in the “Community Rights” drop down list to specify how the host processes SNMP requests from the selected community. Normally READ ONLY is recommended.
In the “Community Name” box, type public or any case-sensitive community name that you want.
Click on Add button.
In order for the SNMP service to accept and receive SNMP request packets from any host on the network, including external remote host regardless of identity, click Accept SNMP packets from any host.
To limit the acceptance of SNMP packets, click Accept SNMP packets from these hosts, and then click Add, and then type the appropriate host name, IP or IPX address in the Host name, IP or IPX address box. You can restrict the access to local host or limited servers only by using this setting. Finish off by clicking Add button again.
Click OK when done. Note that you may need to reboot for the settings to take effect.

iftop

2010-09-01T05:35:00.001-07:00

iftop show bandwidth usage like top show cpu and memory usage.

First install required software.

yum install libpcap libpcap-devel ncurses ncurses-devel

Now install iftop. Make sure you download latest version from visiting the site http://www.ex-parrot.com/pdw/iftop/

cd /usr/local/src
wget http://www.ex-parrot.com/pdw/iftop/download/iftop-0.17.tar.gz
tar -zxvf iftop-0.17.tar.gz
cd iftop-0.17
./configure
make && make install

By default iftop monitor eth0. To monitor traffic on eth1, run

iftop -i eth1

Install VNstat on nagios

2010-09-01T05:26:00.000-07:00

cd /usr/local/src
wget http://humdi.net/vnstat/vnstat-1.10.tar.gz
tar -zxvf vnstat-1.10.tar.gz
cd vnstat-*
make
make install

Create Database

To monitor eth1

/usr/bin/vnstat -u -i eth1

For eth0

/usr/bin/vnstat -u -i eth0

Set init Script

cp examples/init.d/redhat/vnstat /etc/init.d
chkconfig --add vnstat
chkconfig vnstat on
service vnstat start

After installation, it take some time to generate bandwidth usage stats. So you need to wait few hours before you can check the stats. During the time, vnstat cronjob runs and collect data from your server to generate the report.

To see the bandwidth usage stat

vnstat
vnstat -d
vnstat -m

Here is an sample vnstat report
[root@server18 vnstat-1.5]# vnstat
Database updated: Thu Jan 10 10:52:36 2008

       eth1

          received:       5.24 MB (3.3%)
       transmitted:     147.44 MB (96.7%)
             total:     152.68 MB

                       rx     |     tx     |  total
       -----------------------+------------+-----------
           today      5.24 MB |  147.44 MB |  152.68 MB
       -----------------------+------------+-----------
       estimated        11 MB |     324 MB |     335 MB
[root@server18 vnstat-1.5]#

New version joomla 1.5.14

2009-10-12T00:29:00.001-07:00

Some changes

MRTG with Nagios

Creating a file based logging script

This is an example page to show you how to use logger.

Introduction To Xajax

PHP Class functions

PHP - Visibility (public, private, protected)

PHP 5 with OOPs

You MUST include the class definition on *every page* when you store an object

New features in PHP 6

Unicode

Register Globals to go

Magic Quotes to go

Safe Mode to go

'var' to alias 'public'

Return by Reference will error

zend.ze1 compatbility mode to go

Freetype 1 and GD 1 support to go

dl() moves to SAPI only

FastCGI always on

Register Long Arrays to go

Extension Movements

PHP Engine Additions

OO changes

Additions to PHP

Conclusion

Add mrtg to nagios

Step # 5 : Commands to Configure mrtg

Install and Enable SNMP Service in Windows XP, Vista and 2003

iftop

Install VNstat on nagios

Set init Script

New version joomla 1.5.14

You MUST include the class definition on every page when you store an object