Request Processing in ATG

In every web application request plays a very important role.User(browser) need to send request to server to access any web resource.

ATG performs below steps to process requests it receives.

1. When a user requests a page(send request to server).Web server parses the request and holds in an HTTPServletRequest object.
2. The Web server passes the HTTPServletRequest to the application server.It wraps the request in its own flavor of request around the generic one before passing it to the Web application.
3. If you defined custom filters and the request is for a JHTML page, the filters execute in the order you specified.
4. Any custom J2EE servlets are processed.
5. The Web application calls one of the following resources.

•  DynamoProxyServlet( DAS servlet pipeline for JHTML requests).
•  PageFilter (DAF servlet pipeline for JSP requests).

     6. The request is passed on to a pipeline of servlets.
     7. If you created custom filters and a JSP is being requested, they execute after the last pipeline servlet, but before the request returns to the application server.
     8. After the servlet pipeline reaches the end, it returns the request to the application server for final processing. 

Below diagram illustrates ATG request processing.
 

Note : DAS pipeline is invoked in the case of JHTML.Because JHTML is a proprietary language, it relies on the page compiler provided in the DAS servlet pipeline to generate JHTML into a servlet that is rendered as HTML by the application server.

Encrypting strings using java

Encryption : Encryption is the science of encoding and decoding secret messages.The message or information (referred to as plain text) is encrypted using an encryption algorithm, turning it into an unreadable cipher text . This is usually done with the use of an encryption key, which specifies how the message is to be encoded. Any adversary that can see the cipher text should not be able to determine anything about the original message. An authorized party, however, is able to decode the cipher text using a decryption algorithm, that usually requires a secret decryption key, that adversaries do not have access to. 

Here is the idea,how this can be done , for example password encryption.

• First accept user password.
• Encrypt password using random salt.
• Store the salt and encrypted password.
• For verification accept password from user.
• Fetch and decode salt for user.Already stored above.
• Encrypt user entered password using decoded salt.
• Now compare encrypted password with already stored encrypted password.Then take the action accordingly.

Below code demonstrates how to encrypt strings(password) using java.

package com.test;

import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * This class contains code for encryption demo. 
 * 
 * @author Jagdev
 * 
 */

public class EncryptionTest {

/**
* @param args
* @throws NoSuchAlgorithmException
* @throws IOException
*/
public static void main(String[] args) throws NoSuchAlgorithmException,
IOException {
// String password
String password = "Jagdev";
// Hash function iterations
int iterationNb = 5000;
// SecureRandom object that implements the SHA1PRNG Random Number
// Generator (RNG) algorithm
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
// Salt generation 64 bits long
byte[] bSalt = new byte[8];
random.nextBytes(bSalt);
MessageDigest digest = MessageDigest.getInstance("SHA-1");
digest.update(bSalt);
byte[] input = digest.digest(password.getBytes("UTF-8"));

for (int i = 0; i < iterationNb; i++) {
input = digest.digest(input);
}

BASE64Encoder endecoder = new BASE64Encoder();
// encode the password using BASE64Encoder
String encodedPassword = endecoder.encode(input);
System.out.println("Encoded password is " + encodedPassword);
System.out.println("Salt is = " + new String(bSalt));
// encode the salt using BASE64Encoder
String encodedSalt = endecoder.encode(bSalt);
                //Code for encode string using decoded salt.
BASE64Decoder decoder = new BASE64Decoder();
// decode the encodedSalt
byte[] decodedSalt = decoder.decodeBuffer(encodedSalt);
// reset the digest
digest.reset();
// update the digest using decoded salt
digest.update(decodedSalt);
input = digest.digest(password.getBytes("UTF-8"));

for (int i = 0; i < iterationNb; i++) {
input = digest.digest(input);
}

String encodedpassword = endecoder.encode(input);
System.out.println("Encoded password is " + encodedpassword);
System.out.println("Decoded salt is = " + new String(decodedSalt));
}

}

Endeca “Failed to obtain lock” indexing error solution

While running baseline or partial indexing,you may encounter the below error.

INFO:Checking definition from AppConfig.xml against existing EAC provisioning.
INFO:Definition has not changed.
INFO:Starting baseline update script.
WARNING:Failed to obtain lock. 

Below is the reason behind this.

If running script breaks halfway through its execution due to an unhandled exception, or is manually interrupted 

by a user pressing Ctrl-C while it is running, the lock remains set within the EAC.  

To resolve this use below commands.

On Windows: .\runcommand.bat LockManager releaseLock update_lock
On UNIX: ./runcommand.sh LockManager releaseLock update_lock

Now run the indexing,it will work.