JQuery is one of the best Javascript libraries out there, which combines ease of use and powerful, yet simple to use plugins for almost everything you could imagine or need.  Also, it provides a solid foundation for you to write your code for your custom needs.

When working with forms, we always need to deal with form validation.  It’s just something we can’t ignore or evade, since it’s critical for useful and friendly application.  In this sense, JQuery has a great Validation Plugin that deals with all your general form validation needs: required fields, dates, numeric ranges, and many more.

But there are times in which you need to create a custom validation rule.  Maybe because of your business or a specific rule your customer requested you.  In this case, the Validation Plugin offers a pretty simple way to extend the basic rules, by adding your very own validation methods.

This is achieved by adding a custom validation function using the function  $.validator.addMethod() inside the $(document).ready() function of JQuery:

$(document).ready(function(){

  $.validator.addMethod("myCustomRule", function(value, element) {
    //Any code that will return TRUE or FALSE
  },
  "Error message");

});

The method has 3 main parts:

• The rule name (called myCustomRule in this example)
• The Javascript function that will return either TRUE or FALSE, with the actual validation you need.  If the validation goes fine, it’ll return TRUE, and if something fails it returns FALSE.
• The error message that will be shown to the user when the validation code returns FALSE.

So for example, imagine we need to add a custom validation rule that checks that a date entered by the user is higher than the current date (than today). In this case, we’ll need to add the following validation function with the $.validator.addMethod function:

$.validator.addMethod("dateHigherThanToday", function(value, element) {
  //If false, the validation fails and the message below is displayed
  var myDate = value;
  return Date.parse(myDate) > new Date();
  }, "Date must be higher than current date");

After this, you only need to reference your new validation method in your form, either by defining your rules in Javascript, or by adding the validation methods in the input’s class attribute, like this:

<input id="date" type="text" class="required date dateHigherThanToday" />

As with any other validation rules from the plugin, you can combine as many as you need to make sure you cover all your validation needs.  In this case, we’re telling that the field date is mandatory (required), must have a date format and must have a date higher than today’s date (our new custom rule).  If any of these rules fail, the form won’t be submitted and the user will receive an error message depending on the rule that failed.

Cheers!

Being a Java developer for almost 10 years now, when I had to move to PHP I chose CodeIgniter for the following reasons:

• Easy to install and configure (being a newbie in PHP this was crucial)
• Clean and elegant MVC implementation
• Uses Active Record pattern for database access
• Overall small footprint and good performance

Usually when you are building a program, the login/logout functionality is a must we always have to go through, so this quick tutorial will focus on this functionality, taking advantage of the benefits of using CodeIgniter instead of doing it from scratch in PHP.

Requirements

• CodeIgniter framework.  By the time this tutorial was done, the latest version was 2.0.2
• Any Apache/PHP/MySQL stack.  You can install the applications independently, or install one of those packages that have all of them bundled together.

Installing CodeIgniter

To install CodeIgniter, you only need to uncompress the Zip file you download from the site into your htdocs directory and you’re good to go.  We’ll configure the database access later.

Create the database

For this tutorial, you need a MySQL database with the following table:

CREATE TABLE `users` (
 `id` tinyint(4) NOT NULL AUTO_INCREMENT,
 `username` varchar(10) NOT NULL,
 `password` varchar(100) NOT NULL,
 PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Remember also to add at least one user.  We’ll add one user called bob with password supersecret.

insert into users (username, password) values ('bob', MD5('supersecret'));

Configure CodeIgniter

Database Access

Update the file application/config/database.php in your CodeIgniter installation with your database info:

$db['default']['hostname'] = 'localhost';
$db['default']['username'] = 'yourdbusername';
$db['default']['password'] = 'yourdbpassword';
$db['default']['database'] = 'yourdbname';

Default Controller

We need to tell CodeIgniter to land into our login page instead of the default welcome page.  Update the file application/config/routes.php in your CodeIgniter installation with you controller’s name.  We’ll call our landing controller login.

$route['default_controller'] = "login";

Default Libraries

In the file application/config/autoload.php you can configure the default libraries you want to load in all your controllers.  For our case, we’ll load the database and session libraries, since we want to handle user sessions, and also the URL helper for internal link generation

$autoload['libraries'] = array('database','session');

$autoload['helper'] = array('url');

Encryption Key

When you use the session library, you need to set the encryption_key in the file application/config/config.php.

$config['encryption_key'] = 'REALLY_LONG_NUMBER';

The Code

Here are the actual Views, Controllers and Model we are using for the login functionality.

User Model (application/models/user/php)

<?php
Class User extends CI_Model
{
 function login($username, $password)
 {
   $this -> db -> select('id, username, password');
   $this -> db -> from('users');
   $this -> db -> where('username = ' . "'" . $username . "'");
   $this -> db -> where('password = ' . "'" . MD5($password) . "'");
   $this -> db -> limit(1);

   $query = $this -> db -> get();

   if($query -> num_rows() == 1)
   {
     return $query->result();
   }
   else
   {
     return false;
   }
 }
}
?>

Login Controller (application/controllers/login.php)

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

class Login extends CI_Controller {

 function __construct()
 {
   parent::__construct();
 }

 function index()
 {
   $this->load->helper(array('form', 'url'));
   $this->load->view('login_view');
 }

}

?>

Login View (application/views/login_view.php)

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
   <title>Simple Login with CodeIgniter</title>
 </head>
 <body>
   <h1>Simple Login with CodeIgniter</h1>
   <?php echo validation_errors(); ?>
   <?php echo form_open('verifylogin'); ?>
     <label for="username">Username:</label>
     <input type="text" size="20" id="username" name="username"/>
     <br/>
     <label for="password">Password:</label>
     <input type="password" size="20" id="passowrd" name="password"/>
     <br/>
     <input type="submit" value="Login"/>
   </form>
 </body>
</html>

VerifyLogin Controller (application/controllers/verifylogin.php)

This controller does the actual validation of the fields and checks the credentials against the database.

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

class VerifyLogin extends CI_Controller {

 function __construct()
 {
   parent::__construct();
   $this->load->model('user','',TRUE);
 }

 function index()
 {
   //This method will have the credentials validation
   $this->load->library('form_validation');

   $this->form_validation->set_rules('username', 'Username', 'trim|required|xss_clean');
   $this->form_validation->set_rules('password', 'Password', 'trim|required|xss_clean|callback_check_database');

   if($this->form_validation->run() == FALSE)
   {
     //Field validation failed.  User redirected to login page
     $this->load->view('login_view');
   }
   else
   {
     //Go to private area
     redirect('home', 'refresh');
   }

 }

 function check_database($password)
 {
   //Field validation succeeded.  Validate against database
   $username = $this->input->post('username');

   //query the database
   $result = $this->user->login($username, $password);

   if($result)
   {
     $sess_array = array();
     foreach($result as $row)
     {
       $sess_array = array(
         'id' => $row->id,
         'username' => $row->username
       );
       $this->session->set_userdata('logged_in', $sess_array);
     }
     return TRUE;
   }
   else
   {
     $this->form_validation->set_message('check_database', 'Invalid username or password');
     return false;
   }
 }
}
?>

Home Controller (application/controllers/home.php)

This is the private page (only authenticated users can access it).

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
session_start(); //we need to call PHP's session object to access it through CI
class Home extends CI_Controller {

 function __construct()
 {
   parent::__construct();
 }

 function index()
 {
   if($this->session->userdata('logged_in'))
   {
     $session_data = $this->session->userdata('logged_in');
     $data['username'] = $session_data['username'];
     $this->load->view('home_view', $data);
   }
   else
   {
     //If no session, redirect to login page
     redirect('login', 'refresh');
   }
 }

 function logout()
 {
   $this->session->unset_userdata('logged_in');
   session_destroy();
   redirect('home', 'refresh');
 }

}

?>

Home Page View (application/views/home_view.php)

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
   <title>Simple Login with CodeIgniter - Private Area</title>
 </head>
 <body>
   <h1>Home</h1>
   <h2>Welcome <?php echo $username; ?>!</h2>
   <a href="home/logout">Logout</a>
 </body>
</html>

The code is pretty easy to follow and understand.  Also, you can download the code from here, so you can install it and test it in your location.  You’ll only need a full installation of CodeIgniter 2.0.2 and the table in your MySQL database.  If you need any help, feel free to leave us a comment or shoot us an email.

Also, this code uses a pretty basic form validation from CodeIgniter.  If you need a more complex validation process, check CodeIgniter’s Form Validation docs at their site.

Cheers!

Why set up Glassfish behind Apache?

When started, Glassfish opens two HTTP ports by default: 8080, which is the usual HTTP port where all your WAR applications are available, and also port 4848, which lets you access the Web Admin Panel.  You don’t need an additional Web server like Apache to use your Glassfish server, but eventually you’ll run into one of the following scenarios that will make you consider having your Glassfish server behind a Web Server like Apache:

• Port 8080 is blocked for your end users.
• People can become suspicious when accessing an unusual domain like http://www.mysuperapplication.com:8080
• You need to set up several instances of Glassfish (e.g. dev and live), and need to keep each of them in its own JVM

For this configuration, you’ll need the following:

• JDK 1.6
• Apache 2.2 up and running (default installation is fine)
• Tomcat mod_jk connector
• Glassfish 3.1 Open Source Edition

This configuration was successfully deployed in CentOS 5.5, but should be easily ported to other Linux distributions, or even a Windows-based server.

Installing Glassfish:

Installing Glassfish is just a matter of unzipping the package file (zip or tar.gz) you downloaded in any location in your server.  We recommend you create a low-privilege user in your Linux server and run Glassfish with this user. It is not a good idea to run an application server with root privileges.

After you unzip Glassfish, you can start the server by running this command:

$GLASSFISH_HOME/glassfish/bin/asadmin start-domain

This command will start the default domain included in the server, which is called domain1.  After a few seconds, you should be able to browse to its default page at http://server-ip:8080 or the Web Admin Panel at http://server-ip:4848.

After this, we’ll use the asadmin commnad to to add an http listener called jk-connector-8009, which will listen on port 8009 for AJP connections.  This is the port that Apache will use to redirect requests from port 80 to Glassfish, and back to Apache.

Create the listener:

$GLASSFISH_HOME/glassfish/bin/asadmin --user admin --host localhost --port 4848 create-http-listener --listeneraddress 0.0.0.0 --listenerport 8009 --defaultvs server jk-connector-8009

Activate the listener:

$GLASSFISH_HOME/glassfish/bin/asadmin --user admin --host localhost --port 4848 set configs.config.server-config.network-config.network-listeners.network-listener.jk-connector-8009.jk-enabled=true

Finally, restart the Glassfish Server:

$GLASSFISH_HOME/glassfish/bin/asadmin stop-domain
$GLASSFISH_HOME/glassfish/bin/asadmin start-domain

Configuring Apache

Download the Tomcat mod_jk connector and place the .so file in your modules directory (e.g. /etc/httpd/modules)
Create a file called workers.properties and place it in a safe place (e.g. /etc/httpd/conf.d).  Put the following contents in this file:

worker.list=worker1
worker.worker1.type=ajp13
worker.worker1.host=localhost
worker.worker1.port=8009

Then, open your httpd.conf file and put the following contents in it (outside a VirtualHost section).  Check the path of your workers.properties file

JkWorkersFile /path/to/workers.properties
JkLogFile /var/log/httpd/mod_jk.log
JkLogLevel debug
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "
JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories
JkRequestLogFormat "%w %V %T"

Also, you need to add a VirtualHost section in your page, in order to map the specific domain/subdomain with the path in Glassfish you want to make visible through Apache:

<VirtualHost 111.111.111.111:80>
  ServerAdmin webmaster@mydomain.com
  ServerName mydomain.com

  ... other stuff

  JkMount /myapp/* worker1

  ... other stuff

</VirtualHost>

The highlighted line tells Apache that all requests that go to http://mydomain.com/myapp/ will be served by worker1, which is connected to port 8009 of localhost, which is the port we opened before in Glassfish.  If you want Glassfish to serve all contents of mydomain.com, change the JKMount to /* worker1.

Finally, restart Apache and you’re all set!  Your Glassfish instance will be visible through Apache by port 80, and therefore you won’t need to open additional ports in your server, and you can use the best of both worlds.

Cheers!

org.apache.catalina.core.AprLifecycleListener init
INFO: The APR based Apache Tomcat Native library which
allows optimal performance in production environments
was not found on the java.library.path

APR stands for Apache Runtime Portable Project which provides a consistent API to the native environment where the application server is running (either Linux, Windows, etc).  This means that Tomcat itself contains this native library, but it is disabled by default, since you need to install first the APR. It is recommended to perform the following steps as root or a sudoer user, since you need access to common and restricted resources in the server

To install the APR, first move the Tomcat Native Library to a common location:

cp $TOMCAT_HOME/bin/tomcat-native.tar.gz /usr/local/src/

Then, download the APR library from Apache’s site and install it in /usr/local/src

cd /usr/local/src

tar -zxvf apr-1.3.9.tar.gz

cd apr-1.3.9

./configure

make all install

This will install the APR libraries at /usr/local/apr.

After this, install Tomcat’s native library:

cd /usr/local/src

tar -zxvf tomcat-native.tar.gz

cd tomcat-native-*-src/jni/native/

./configure --with-apr=/usr/local/apr/bin/apr-1-config

make all install

After this, you only need to tell Tomcat where to find these libraries.  One option is to use the LD_LIBRARY_PATH environment variable:

export LD_LIBRARY_PATH=/usr/local/apr/lib

Or create some symbolic links in the J DK used by Tomcat
After this, restart tomcat and you should see the following message in the log file:

INFO: Loaded APR based Apache Tomcat Native library 1.1.16.

Services provided:

• Domain registry and hosting
• GoogleApps configuration (email, calendar, docs)
• Installation, configuration and customization of Joomla!
• Facebook Integration
• Google Analytics and Piwik setup to track hits and favorite pages

To profile local applications is pretty easy, since you only need to start it and it’ll detect all Java-based applications and you’ll be able to see the Heap/PermGen usage, the number of threads used, the classes loaded by the class loader and other stuff.
When it comes really handy is to profile and troubleshoot remote applications (e.g. profile a Tomcat instance in a remote server).  In order to do these, you should only start the application jstatd in the remote server, open the required ports and you’re ready.  Here are the steps to do it:

The jstatd tool is an RMI server application that provides a interface to allow remote monitoring tools to attach to JVMs running on the local host.

It is located in the JDK’s bin directory, located at $JAVA_HOME/bin, and in order to run it, you need to create policy file to enable jstatd to run without security exceptions.  For this, create a file called jstatd.all.policy in $JAVA_HOME/bin and paste the following contents into it:

grant codebase "file:${java.home}/../lib/tools.jar" {
permission java.security.AllPermission;};

Then, just run the jstatd application from the command line, like this:

./jstatd -J-Djava.security.policy=jstatd.all.policy

After this, check the ports that need to be opened to allow the remote instance of VisualVM to connect to it. This application opens 2 ports: the default RMI port, which is 1099, and then a random port, which changes every time you start the application.  To check which ports are used by jstatd, run the following command:

netstat -nlp | grep jstatd

And you should get an output like this:

tcp        0      0 :::39779                :::*              LISTEN      28661/jstatd
tcp        0      0 :::1099                 :::*              LISTEN      28661/jstatd

The 4th column indicates the ports that are open.  In this case, the ports that need to be opened in the firewall are 1099 and 39779.  To open this, you should check IPTables documentation for how to accomplish this.

After all ports are opened and jstatd is running, just open VisualVM, right click on Remote and select Add Remote Host, and finally type the IP address of the remote host.  After this, you’ll be able to see all Java-based applications running in the remote server, including Tomcat, Ant, jstatd and any other.
The following screenshot shows a local VisualVM profiling an instance of Tomcat running in a remote host (click to enlarge):