Reason - Apache has been installed on windows and unable to start because HTTPS  configuration.

Solution -

• a. Remove/comment SSLPassPhrase context fromssl.conf or httpd.conf
• b. Make a copy of the private key and call it “server.key.org”
• c. Use the OpenSSL command to remove the passphrase such as;

# openssl rsa -in server.key.org -out server.key

server.key will be your new private key with the passphrase removed.

Restart apache httpd service.

#openssl genrsa -des3 -out server.passwd.key 1024

#openssl rsa -in server.passwd.key -out server.key

#openssl req -new -key server.key -out server.csr

#openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt

Following are the different ways to log messages using Log4J

• Log.debug (“Debug Message”);
• Log.info (“Info Message”);
• Log.warn (“Warning Message”);
• Log.error (“Error Message”);

But sometime we need to log exception along with stacktrace, for that we need to use

LOG.log(Level.ERROR, exception.getMessage(), exception);

No special configuration required for this behaviour.

We assume you have openssl module/package installed on your system or server .
The openssl toolkit is used to generate an RSA Private Key and CSR (Certificate Signing Request). It can also be used to generate self-signed certificates which can be used for testing purposes or internal usage. The utility used to do all of these tasks is known simply as openssl. It should be installed in the /usr/local/ssl/bin directory. You may want to add this directory to your PATH, or copy or link the openssl utility to a directory that is already in your PATH so that you do not have to type the full path to the executable. The examples below will assume that openssl is in a location that is accessible to you without using the full path to the command.

The first step is to create your RSA Private Key. This key is a 1024 bit RSA key which is encrypted using Triple-DES and stored in a PEM format so that it is readable as ASCII text. We will use several files as random seed enhancers which will help to make the key more secure. Text files that have been compressed with a utility such as gzip are good choices. The key is generated using the following command, where file1:file2:etc represents the random compressed files.

$ openssl genrsa -des3 -rand file1:file2:file3:file4:file5 -out server.key 1024

The command will prompt you for a pass-phrase and then store the key in the file server.key. It is critical that the pass-phrase be secure and not forgotten. If either the key is lost, or the pass-phrase is forgotten, the certificate will be useless! It cannot be stressed enough how important the private key is to the certificate. If the private key and pass-phrase are compromised, the certificate will have to be revoked, costing you the price of the certificate all over again if you have paid an authority for the certificate. It may be a wise idea to back this file up to secure media, such as tape or diskette.

One unfortunate side-effect of the pass-phrased private key is that Apache will ask for the pass-phrase each time the web server is started. Obviously this is not necessarily convenient as someone will not always be around to type in the pass-phrase, such as after a reboot or crash. mod_ssl includes the ability to use an external program in place of the built-in pass-phrase dialog, however, this is not necessarily the most secure option either. It is possible to remove the Triple-DES encryption from the key, thereby no longer needing to type in a pass-phrase. If the private key is no longer encrypted, it is critical that this file only be readable by the root user! If your system is ever compromised and a third party obtains your unencrypted private key, the corresponding certificate will need to be revoked. With that being said, use the following command to remove the pass-phrase from the key:

$ openssl rsa -in server.key -out server.pem

Once the private key is generated a Certificate Signing Request can be generated. The CSR is then used in one of two ways. Ideally, the CSR will be sent to a Certificate Authority, such as Thawte or Verisign who will verify the identity of the requestor and issue a signed certificate. The second option is to self-sign the CSR, which will be demonstrated in the next section.

During the generation of the CSR, you will be prompted for several pieces of information. These are the X.509 attributes of the certificate. One of the prompts will be for “Common Name (e.g., YOUR name)“. It is important that this field be filled in with the fully qualified domain name of the server to be protected by SSL. If the website to be protected will be https://www.server.com, then enter www.server.com at this prompt. The command to generate the CSR is as follows:

$ openssl req -new -key server.key -out server.csr

A sample CSR generation session is shown below, with sample responses shown in bold:

$ openssl req -new -key server.key -out server.csr
Using configuration from /usr/local/ssl/openssl.cnf
Enter PEM pass phrase:Enter pass phrase here

You are about to be asked to enter information that will be incorporated into your certificate request.

What you are about to enter is what is called a Distinguished Name or a DN. There are quite a few fields but you can leave some blank.

For some fields there will be a default value, If you enter ‘.’, the field will be left blank.

—–

Country Name (2 letter code) [AU]:IN
State or Province Name (full name) [Some-State]:Maharshtra
Locality Name (eg, city) []:Mumbai
Organization Name (eg, company) [Internet Widgits Pty Ltd]:ITQuery Tech
Organizational Unit Name (eg, section) []: Web

Common Name (eg, YOUR name) []:www.itquery.com
Email Address []:webmaster@itquery.com

Please enter the following ‘extra’ attributes to be sent with your certificate request
A challenge password []:
An optional company name []:

Generating a Self-Signed Certificate

At this point you will need to generate a self-signed certificate because you either don’t plan on having your certificate signed by a CA, or you wish to test your new SSL implementation while the CA is signing your certificate. In my experience dealing with Thawte, it can take up to a week or more before receiving your signed certificate. The time it takes to receive the certificate will vary based on how quickly they receive your required documentation. This temporary certificate will generate an error in the client browser to the effect that the signing certificate authority is unknown and not trusted.

To generate a temporary certificate which is good for 60 days, issue the following command:

$ openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt

Try following these steps incase if you do not want to ssl certificate with passphrase, since it ask everytime you restart your apache service. Ensure that you have correct certificate name with your apache config.

$openssl rsa -in server.key -out server.key.nopass

Installing the Private Key and Certificate

When Apache with mod_ssl is installed, it creates several directories in the Apache config directory. The location of this directory will differ depending on how Apache was compiled. If using my instructions on compiling Apache, the config directory is /usr/local/apache/etc. The directories mod_ssl creates include ssl.crt, ssl.csr, and ssl.key. These are good locations to store server certificates, CSRs, and private keys, respectively. If there will be multiple SSL enabled hosts on one server, it may be good practice to name the files with the fully qualified domain name of the SSL enabled host.

When adding SSL enabled virtualhosts to the web server, I prefer to keep all of the SSL virtualhosts in a separate file. This insures that all SSL hosts can be easily found in one location and helps to keep the httpd.conf file from growing too large. The SSL virtualhosts will be kept in a file called ssl.conf. In order for Apache to recognize and parse this file, it must be included in the httpd.conf file with the following directive:

Include /usr/local/apache/etc/ssl.conf

Configuring SSL Enabled Virtual Hosts

Extensive examples of SSL configurations for a virtualhost are included as part of the /usr/local/apache/etc/httpd.conf.default file installed with mod_ssl. Please refer to this file and to the mod_ssl documentation for more detailed information on configuration options. A basic SSL enabled virtualhost will appear as follows in the ssl.conf file:

# SSL Virtual Hosts

ServerAdmin webmaster@domain.com
DocumentRoot /usr/local/apache/share/htdocs
ServerName www.domain.com
ScriptAlias /cgi-bin/ /usr/local/apache/share/htdocs/cgi-bin/
SSLEngine on
SSLCertificateFile /usr/local/apache/etc/ssl.crt/server.crt
SSLCertificateKeyFile /usr/local/apache/etc/ssl.key/server.pem
SetEnvIf User-Agent “.*MSIE.*” nokeepalive ssl-unclean-shutdown
CustomLog /usr/local/apache/var/log/ssl_request_log \”%t %h %{SSL_PROTOCOL}x %{SSL_CIPHER}x \”%r\” %b”

This will create an SSL virtualhost named www.domain.com, which is accessed via port 443 (the standard port for https) on the default IP address of the web server. It is possible to add as many additional virtualhosts as there are IP addresses that the web server listens to. Simply add additional virtualhost blocks inside of the and tags. Due to the nature of the SSL encryption of the HTTP traffic, it is NOT possible to have name-based (HTTP1.1) SSL virtual hosts. To create a new SSL virtualhost on a different IP address, simply replace _default_ with the IP address of the virtualhost.

Restart apache to load the new changed configuration file.

– Test the configuration file (httpd.conf).
# apachectl configtest

– Restart the apache
# apachectl restart

1. I would advice to use Apache http web server module “mod_jk” instead of “mod_proxy” because of following reasons -

• It has greater control to manage the request/response internally between Apache’s http and tomcat server.
• This will enable to have internal software load balancing with greater control options, if required.
• It is more secure then mod_proxy.
• Detailed log mechanism to figure out any communication errors.
• Greater control over option what you want to server from which server internally (ie. static content from http server and java content from tomcat)
• Support for large AJP packet sizes (“mod_proxy_ajp” does not support large 8K+ packet sizes).
• Advanced node failure detection (if load balancer mechanism used).

* Only biggest advantage of using mod_proxy* module is easy and short configuration in Apache conf file to achieve integration.

2. SSL certificate should be installed on Apache’s http server instead of tomcat.
3. Tomcat should be running on separate port other than standard http and https port.
4. Apache’s http webserver should be running on standard http and https ports. It is easy feasible to secure Apache’s http server instead of tomcat server, since tomcat is not a full featured web server.

ANT can be used as great tool for tokenizing user input during application builiding process. This script will take a string from user input and tokenize in multiple string.

Limitation : Currently this script tokenize single seperator only.

Example

split:
[input] Enter site name
www.google.com
[input] Enter seperator
\.
[echo] www
[echo] google
[echo] com

The script is as follows :

<?xml version=”1.0″ encoding=”UTF-8″?>
<project name=”Split input parameter” basedir=”.” default=”split”>

<taskdef resource=”net/sf/antcontrib/antlib.xml”>
<classpath>
<pathelement location=”${basedir}/lib/ant-contrib-1.0b3.jar”/>
</classpath>
</taskdef>

<scriptdef name=”split” language=”javascript”>
<attribute name=”value”/>
<attribute name=”sep”/>
<attribute name=”prefix”/>
<![CDATA[
values = attributes.get("value").split(attributes.get("sep"));
str = "";
for(i=0; i<values.length; i++) {
str = str + "," + values[i];
}
str = str.substring(str.indexOf(“,”) + 1, str.length);
project.setNewProperty(attributes.get(“prefix”),    str);
]]>
</scriptdef>

<target name=”split” description=”Tokenised input parameter”>
<input message=”Enter site name” addproperty=”site”/>
<input message=”Enter seperator” addproperty=”seperator”/>
<split value=”${site}” sep=”${seperator}” prefix=”value”/>
<property name=”list” value=”${value}”/>
<for list=”${list}” param=”letter”>
<sequential>
<echo message=”@{letter}”/>
</sequential>
</for>
</target>
</project>

#adduser <User_Name>
This will create a user with default home directory settings defined on system

ie. Home directory path(when user log into system will see this directory) will  be  /home/User_Name

If you want to add custom path for user’s home directory

#adduser <User_Name> -d /opt/User_Name
Here you are assigning home directory with option -d

If you want to add custom home directory path and add user into an existing group.

#adduser <User_Name> -d /opt/User_Name -g Group_Name

Adding a parameter -g will assign this new user under given existing group along with custom home directory path.

Force user to change password on their first successful login

#chage -d 0 User_Name

You can have your SQL Query saved as a file “QUERY.sql”

SELECT FIELD1, FIELD2, FIELD3 … from TABLEName
WHERE COLUMNName = ‘$VALUE’
INTO OUTFILE ‘/tmp/DataFile_output.csv’
FIELDS TERMINATED BY ‘,’
ENCLOSED BY ‘”‘
LINES TERMINATED BY ‘\n’

Now run this query

$mysql -uuser_name -ppassword databasename < /path/to/sqlfile/QUERY.sql

Even this this can be schedule in cron for cronjob routine.

Cheers!

Save below script as “Ftpenv.sh”

#!/bin/sh
############################################################
# File:         Ftpenv.sh
# Description:  Setup Environment Variables for FTP task by itquery
############################################################

REMOTE_FTP_SERVER=192.168.0.1   # Server where to put the Incremental Load files
REMOTE_FTP_USER=ftpuser                # User to login at REMOTE_FTP_USER
REMOTE_FTP_PASSWORD=ftppassword #Passwd for FTP usr at REMOTE_FTP_USR
REMOTE_FTP_DIR=/opt/remoteftparea   # Directory where to put the files
SOURCE_DIR=/opt/localftparea                   # Directory from where file is FTP’d

TIMESTAMP=`date +%d%m%Y`
LOGFILE=/opt/FTP_$TIMESTAMP.log     # Log file

log() { echo “`date +%H:%M` – $1″ >> $LOGFILE; }

Save below script as Ftpscript.sh

#!/bin/sh
################################################################
# File:         Ftpscript.sh
# Description:  Trasfer file if they are changed and are more than 0 byte onto remote area # using FTP protocol task by itquery
################################################################
. `dirname $0`/Ftpenv.sh

log “$0 – Start of Execution”
# Get ready for FTP, from the source directory
cd $SOURCE_DIR
#————————————————-
# Use additonal USER’s environment variable of $HOME/.bash_profile file for ftp transfer. ~/.bash_profile

#——————————–
# Checks if the remote server is responding
/bin/ping “$REMOTE_FTP_SERVER” 64 1 >>$LOGFILE
if [ $? -ne 0 ]
then
log ” Server (“$REMOTE_FTP_SERVER”) is not responding…FTP aborted”
exit 1
fi

#———————–
# Transfer only new/files greater than 0 byte files via FTP.
ftp $REMOTE_FTP_SERVER  1>>$LOGFILE <<EOF
cd $REMOTE_FTP_DIR
for FILE in `ls -1  $SOURCE_DIR`
do
FoundFile=`find  $FILE -mtime -2 |wc -l`
if [ "$FoundFile" -gt "0" ]
then
echo “Transferring $FILE now..”
put $FILE
else
echo “Nothing to Trasnsfer”
fi
done
quit
EOF

#———————————————————–
#Archiving the FTP’d file to a new location $SOURCE_DIR/Done
#mv $SOURCE_DIR/LOG_$TIMESTAMP.DAT.gz $SOURCE_DIR/Done
log “$0 – End of Execution”
exit 0

var loadData = (function () {
  var _this;

  return {
    response: null,
    url: null,
    writeDataOfId: null,
    data: null,
    writeDataToId: null,
    dummyDiv: null,

    init: function (url, writeDataOfId, writeDataToId) {
      if (!url && !writeDataOfId && !writeDataToId) {
        return; // don't do anything if none of the parameters are present
      }
      _this = this;
      this.writeDataToId = document.getElementById(writeDataToId);
      if (!this.writeDataToId) {
        return;
      }
      this.url = url;
      this.writeDataOfId = writeDataOfId;
      this.ajax();
    },
    ajax: function () {
      var xhr = null;
      try {
        xhr = new window.XMLHttpRequest();
      } catch (e) {
        try {
          xhr = new window.ActiveXObject('Microsoft.XMLHTTP');
        } catch (e) {
          throw new Error('Not Supported');
        }
      }
      if (xhr) {
        xhr.open('GET', this.url, false);
        xhr.send(null);
        xhr.onreadystatechange = function () {
          if (xhr.readyState == 4) {
            if (xhr.status == 200) {
              _this.response = xhr.responseText;
              _this.writeData();
            } else {
              throw new Error('Error Occurred!!!');
            }
          }
        };
      }
    },
    writeData: function () {
      var elem;
      if (!this.response) {
        return;
      }
      this.dummyDiv = document.createElement('div'); //dummy div to hold the data so that dom methods can be
                                                     //performed to get the elements.
      this.dummyDiv.innerHTML = this.response;
      elem = this.findElem();
      if (elem) {
        this.writeDataToId.innerHTML = elem.innerHTML;
      } else {
        throw new Error('Error Occurred!!!');
      }
      this.dummyDiv = null; // free the memory after the use of dummyDiv is done.
    },
    findElem: function () {
      var i = 0, allTags = this.dummyDiv.getElementsByTagName('*'), l = allTags.length, elem;
      for (; i < l; i++) {
        elem = allTags[i];
        if (elem.getAttribute('id') === this.writeDataOfId) {
          return elem;
        }
      }
      return null;
    }
  };
}());

// and in dom ready make a call like this

loadData.init(<url>, <id u want to get data of>, <id in which you want to write the data>);

I know this is not so good of a post, but hope this gives you a little bit of idea what i’m trying to say.

Cheers!!!