How to serve stale content in case no render is available

In order to enable this feature, an additional flag /serveStaleOnError has to be set below the/cache section:

dispatcher.any

/cache     # Flag indicating whether the dispatcher should serve stale content if   # no remote server is available.   /serveStaleOnError "1"

Please note that only the following response codes are considered:

• 502 - Bad Gateway
• 503 - Service Unavailable
• 504 - Gateway Timeout

Creating Custom Namespaces

Adobe CQ uses namespaces to maintain modularity between the properties and also tags.  namespaces help in distinguishing different modules of the project. We create thousand of properties in our project and many times it consists of just words. Hence to make the properties names meaningful we can add a namespace to project related namespaces.

Note that the namespace is unique to your project and doesn’t conflict with existing namespaces.

Steps for creating Custom Namespace:

Step 1: Log into CRX and follow this path:http://servername:port/crx/explorer/nodetypes/index.jsp  or click on Node Administration link from the CRX Console.

Step 2:  You will be navigated to the below screen. On the left panel, all the node types will be displayed. Click on the Namespaces link on the right as displayed below:

  

 Step 3: Below screen will appear and click on New button and enter the namespace URI and prefix . The namespace provided below is just an example.

 Step 4: The namespace will be created and it can now be used in your project.

 Let me know if any questions.

Hope this helps. Thanks!

Custom Tag Libs for Adobe CQ

Follow the below steps for creating custom Tab libraries:

Step 1: Write a java Class with the method  you want as a tag lib.

I’m providing an example java class here:

/**

*

*/

package com.company.cq.taglibs;

import javax.servlet.jsp.JspException;

import javax.servlet.jsp.JspWriter;

import javax.servlet.jsp.tagext.DynamicAttributes;

import javax.servlet.jsp.tagext.TagSupport;

/**

* @author apelluru

*

*/

public class ReusableTagLibs extends TagSupport implements DynamicAttributes {

@Override

public int doStartTag() throws JspException {

try {

JspWriter out = pageContext.getOut();

out.print(getLabel(“”,”"));

}catch (Exception e) {

// TODO: handle exception

}

return SKIP_BODY;

}

private String getLabel(String prop, String value) {

return “hello”;

}

public void setDynamicAttribute(String uri, String localName, Object value) {

}

}

Step 2: Write a tld file for your tab library

The path of the tld file may be in  resource/META-INF folder of your src folder. If META-INF folder is not present then create it.

The tld file will look like this:

<?xml version=”1.0″ encoding=”UTF-8″?>

<taglib>

<tlibversion>1.0</tlibversion>

<jspversion>1.1</jspversion>

<shortname>locale</shortname>

<info>Taglib for CQ localization</info>

<tag>

<name>label</name>

<tagclass>com.company.cq.taglibs.ReusableTagLibs</tagclass>

<info>Localization function</info>

<attribute>

<name>property</name>

<required>true</required>

<rtexprvalue>true</rtexprvalue>

<dynamic-attributes>true</dynamic-attributes>

</attribute>

<attribute>

<name>context</name>

<required>true</required>

<rtexprvalue>true</rtexprvalue>

<dynamic-attributes>true</dynamic-attributes>

</attribute>

<attribute>

<name>encoding</name>

<required>false</required>

</attribute>

<dynamic-attributes>true</dynamic-attributes>

</tag>

</taglib>

Step 3: Build the bundle.

Step 4: Include the tag library in your jsp

<%@taglib prefix=”reusable” uri=”/apps/reusablecomponents/dm/src/impl/src/main/resources/META-INF/reusable.tld” %>

Use the tag in your JSP like this:    <reusable:label  property=”hello” context=”<%= pageContext %>”/>

CQ 5.5 upgrade from 5.4 learnings

Here are few learning that I got when we upgraded CQ 5.4 to CQ 5.5:

1. DO NOT customize the out of the box libraries until unless it’s really required. Customizing the OOTB functionality will be problematic when new version of the product add more features on the libraries you’ve overridden.
2. Analytics integration with CQ 5.5 has been made very simple and all the configuration are provided on the CQ side. We used analytics integration in CQ 5.4 hence we re-integrated by modifying the settings.
3. If you have overridden init.jsp(CQ 5.4) in your project then UNDO/REDO won’t work. This is because a new service class has been introduced which handles the undo/redo request and initialized in init.jsp. Hence you need to merge the init.jsp (CQ 5.4) to init.jsp (CQ 5.5).
4. Few API changes has been made. Please checkhttp://dev.day.com/docs/en/cq/current/diff_5-4_5-5/changes.h… for more information. If a class you’ve used in 5.4 doesn’t work, search for alternate class. (Examples: AnalyticsHelper.java has been removed, wrote my own method to get the analytics resource).
5. Maintain at least one instance of CQ 5.4 running as a backup. It will also help in comparing between 5.5 & 5.4.
6. Dropdown/Tag fields in dialogs shrink after upgrade. I fixed it by adding a width property to the fields.
7. If you’ve customized OOTB functionality then you may see many Internal Server Errors. This is due to the Resource Not found Exception since class/configuration in 5.5 has been modified/removed.
8. Delete your workflow instances and temporary data (unused package, tmp files) from CRX before the upgrade. This will help in faster upgrade.
9. Continuous log monitoring will help in finding the issues which doesn’t appear on the UI.
10. Most importantly if New Page options or Page Properties are disabled completely then it may be due to missing “jcr:content” node on the page. Also this may cause due to permissions.
11. LDAP permission were getting wiped out with every deployment of our project package. Adobe has provided a fix for it.
12. Install CQ 5.5.1, it fixes may of the internal issues.
13. Old Scr annotations (E.g., scr.reference) has been deprecated and hence you need to use new scr annotations (@Reference()). Bundles won’t build with the old annotations.

Note: Though our upgrade instance was running fine in Pre-PROD environments, we had a meeting with Adobe, they have validated all the configuration settings, logs and showed a green flag.

Create custom xtype multi textfield, pathfield, new window options

CQ.form.CustomMultiField = CQ.Ext.extend(CQ.form.CompositeField, {

hiddenField: null,

linkText: null,

linkURL: null,

openInNewWindow: null,

constructor: function (config) {

config = config || {};

var defaults = {
    "border": true,
    "labelWidth": 75,
    "layout": "form"
    };  
config = CQ.Util.applyDefaults(config, defaults);
CQ.form.CustomMultiField.superclass.constructor.call(this, config);
},

initComponent: function () {
 
    CQ.form.CustomMultiField.superclass.initComponent.call(this);
 
    // Hidden field
    this.hiddenField = new CQ.Ext.form.Hidden({
         name: this.name
    });
    this.add(this.hiddenField);
 
    this.linkText = new CQ.Ext.form.TextField({
        cls: "customwidget-1",
        maxLength: 100,
        emptyText: "Enter Title",
        maxLengthText: "A maximum of 100 characters is allowed for the Link Text.",
        width: 335,
        allowBlank: true,
        name : "item",
        listeners: {
        change: {
        scope: this,
        fn: this.updateHidden
    }
    }
    });  
    this.add(this.linkText);
 
    this.linkURL = new CQ.form.PathField({
        cls: "customwidget-2",
        allowBlank: true,
        emptyText: "Enter Title URL",
        width: 335,
        listeners: {
         change: {
            scope: this,
            fn: this.updateHidden
        },      
        dialogclose: {
            scope: this,
            fn: this.updateHidden
        }
       }
    });
    this.add(this.linkURL);
 
    // Link openInNewWindow
    this.openInNewWindow = new CQ.Ext.form.Checkbox({
        cls: "customwidget-3",
        boxLabel: "New window",
        listeners: {
        change: {
        scope: this,
        fn: this.updateHidden
        },
        check: {
        scope: this,
        fn: this.updateHidden
    }
    }
    });
    this.add(this.openInNewWindow);
 
},

processInit: function (path, record) {  
    this.linkText.processInit(path, record);
    this.linkURL.processInit(path, record);
    this.openInNewWindow.processInit(path, record);
},

setValue: function (value) {
    var link = JSON.parse(value);
    this.linkText.setValue(link.text);
    this.linkURL.setValue(link.url);
    this.openInNewWindow.setValue(link.openInNewWindow);
},
getValue: function () {
return this.getRawValue();
},

getRawValue: function () {  
    var link = {
    "url": this.linkURL.getValue(),
    "text": this.linkText.getValue(),
    "openInNewWindow": this.openInNewWindow.getValue()
    };  
    return JSON.stringify(link);
},
updateHidden: function () {
this.hiddenField.setValue(this.getValue());
}
});

CQ.Ext.reg("CustomMultiField", CQ.form.CustomMultiField);



Then Dialog



<?xml version="1.0" encoding="UTF-8"?>
<jcr:root xmlns:cq="http://www.day.com/jcr/cq/1.0" xmlns:jcr="http://www.jcp.org/jcr/1.0"
    jcr:primaryType="cq:Dialog"
    width="550"
    xtype="dialog">
    <items
        jcr:primaryType="cq:Widget"
        xtype="tabpanel">
        <items jcr:primaryType="cq:WidgetCollection">
            <tab1
                jcr:primaryType="cq:Panel"
                title="Links Component">
                <items jcr:primaryType="cq:WidgetCollection">
                    <links
                        jcr:primaryType="cq:Widget"
                        border="false"
                        fieldDescription="Press + to add more links"
                        fieldLabel="Links"
                        hideLabel="true"
                        name="./links"
                        xtype="multifield">
                        <fieldConfig
                            jcr:primaryType="cq:Widget"
                            xtype="CustomMultiField"/>
                    </links>
                </items>
            </tab1>
        </items>
    </items>
</jcr:root>

Encryption And Decryption in Java

import javax.crypto.*;
import javax.crypto.spec.*;
import org.apache.commons.codec.binary.*;

 public class DESDecrypt {
 
    private String characterEncoding = "UTF-8";
    private String cipherTransformation = "AES/CBC/PKCS5Padding";
    private String aesEncryptionAlgorithm = "AES";  
 
    private byte[] decrypt(byte[] cipherText, byte[] key, byte[] initialVector) throws Exception
    {
        Cipher cipher = Cipher.getInstance(cipherTransformation);
        SecretKeySpec secretKeySpecy = new SecretKeySpec(key, aesEncryptionAlgorithm);
        IvParameterSpec ivParameterSpec = new IvParameterSpec(initialVector);
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpecy, ivParameterSpec);
        cipherText = cipher.doFinal(cipherText);
        return cipherText;
    }

    private byte[] encrypt(byte[] plainText, byte[] key, byte[] initialVector) throws Exception
    {
        Cipher cipher = Cipher.getInstance(cipherTransformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key, aesEncryptionAlgorithm);
        IvParameterSpec ivParameterSpec = new IvParameterSpec(initialVector);
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
        plainText = cipher.doFinal(plainText);
        return plainText;
    }

    private byte[] getKeyBytes(String key) throws Exception{
 
        byte[] keyBytes= new byte[16];
        byte[] parameterKeyBytes= key.getBytes(characterEncoding);
        System.arraycopy(parameterKeyBytes, 0, keyBytes, 0, Math.min(parameterKeyBytes.length, keyBytes.length));      
        return keyBytes;
    }
 
    public String encrypt(String plainText, String key) throws Exception{
 
        byte[] plainTextbytes = plainText.getBytes(characterEncoding);
        byte[] keyBytes = getKeyBytes(key);
        return Base64.encodeBase64String(encrypt(plainTextbytes, keyBytes, keyBytes));
    }

    public String decrypt(String encryptedText, String key) throws Exception{
     
        byte[] cipheredBytes = Base64.decodeBase64(encryptedText);
        byte[] keyBytes = getKeyBytes(key);
     
        return new String(decrypt(cipheredBytes, keyBytes, keyBytes), characterEncoding);
    }
 
}

CQ5 Interview Questions

 Q) What is CQ5? What is a Content Management System?

CQ5 is a java based content management system from adobe, previously Day CQ5.
1)    It is based on a content repository(i.e it uses a content repository to store the content of a website) and use JCR(java content repository) specification to access the content repository.
2)    It uses RESTful Apache Sling framework to map request url to the corresponding node in content repository
3)    it uses powerful OSGi framework internally to allow modular application development. It means  individual pieces of your application(called bundles in terms of OSGi) can be independently started and stopped. CQ5 uses Apache Felix as the OSGi container. Therefore different parts of cq5 can be independently started and stopped.

Coming to why a content management system is required? Some websites are very dynamic in nature, content needs to be updated frequently, so it is easier to manage the content of such websites using a CMS.

Q)    What is the technology stack of cq5?

CQ5 uses the following technologies :

1)    JCR – java specification for accessing a content repository  JSR-283 specification jcr 2.0 , cq5 uses its own implementation of jcr called CRX. Apache Jackrabbit is an open-source implementation of jcr 2.0 specification.
2)    Apache Sling – RESTful framework to access a jcr over http protocol. It maps the request url to the node in jcr.
3)    OSGi – framework for modular application development using java. Each module called bundle can be independently started and stopped.

Q)    What is a content repository? What is JCR?

A Content repository is basically a place where digital content is stored. Generally the structure of the content repository is hierarchial and represented as a tree structure where each node of the tree is used to store content.

Java Content Repository is a specification provided by the java community to access the content repository in a uniform way (platform independent and vendor independent way). The specification was initially released as JSR-170(JCR 1.0) and then later revised version 2 as (JCR-283).

The javax.jcr API provides the various classes and interfaces to access a content repository

Apache Jackrabbit is an open-source implementation of JCR- 2.0 specification.

It provides some wrapper classes and interfaces specific to jackrabbit plus many more functionalities on top of jcr.

The org.apache.jackrabbit packages are used to access Jackrabbit.

Q) What is Sling? How is it different from other web-development frameworks?

Apache Sling is RESTful framework to access a java content repository over http protocol.

It is a content driven framework that is it maps the incoming user request based on URI to the corresponding node in the content repository and depending on the type of the request(GET,POST, etc) executes the corresponding dynamic script.

For example -  consider a scenario where a user is hitting a US website products page and getting the details of product1.

The incoming URL request from user will be

www.mywebsite.com/products/product1.html

This would be mapped by the sling resource resolver to a node in the JCR

/content/mywebsite/us/products/product1

Now the Sling resource resolver will check the properties of this node and check the sling:resourceType property of this node, which will tell the script that will be used to render the content of this page.

For example if value of sling:resourceType property is /apps/mywebsite/products/GET/body.jsp

Then for all the incoming GET requests on the product1 node, the above script will be used to render the content.
The main advantages of sling are:

a) it maps the url directly to the content
b) it is restful.

Q) How is resource resolution done in Sling?

The below images tells us how a URL is resolved and mapped to a resource.

Consider the URL

GET – www.mywebsite.com/products/product1.printable.a4.html/a/b?x=12

Here the type of request will be HTTP GET request

We can break it down into its composite parts:

protocol	host	content path	selector(s)	extension		suffix		param(s)
http://	myhost	products/product1	.printable.a4.	html	/	a/b	?	x=12

Q) What is OSGi? What is the benefit of OSGi? What is Felix?

OSGi is a framework which allows modular development of applications using java.

A large application can be constructed using     small reusable components(called bundles in terms of OSGi) each of which can be independently started, stopped, and also can be configured dynamically while running without requiring a restart.

Consider a scenario where you have a large application which uses a logging framework. This logging framework can be deployed as an OSGi Bundle, which can be managed independently. Therefore, it can be started when required by our application and can be stopped when not in use. Also the OSGi container makes these bundles available as services, which can be subsribed by other parts of application.

The main advantages of using OSGi :

1)    reduces the complexity of the system.
2)    Makes the components loosely couples and easy to manage.
3)    Increases the performance of the system, since parts of application which are not in use,need not to be loaded in the memory(although there is not a drastic change in performance and also some people argue that running an OSGi container itself takes huge memory).

Q)    What is the role of Dispatcher in CQ5?

Dispatcher is a CQ5 tool for caching and load-balancing. It has 2 responsibilities.

1)    Caching – To cache as much content as possible, so that it doesnt need to access layout engine frequently for generating content dynamically.

2)    Load-balancing – To increase the performance by load-balancing.

Dispatcher uses 2 main strategies for caching.

1)    Cache as much content as possible as static pages.
2)    Accessing layout engine as little as possible.

Note : The Dispatcher uses a Cache Directory for caching static content. The cached documents are created in the root of a web-server.

Dispatcher uses the following methods for caching :
1)    Dispatcher invalidates those pages whose content has been updated and replaces it with new content.
2)    Auto-Inavidation automatically removes the content parts which are out of date.

Coming to load-balancing, if there are multiple cq instances configured with a dispatcher, the dispatcher can do a load-balancing and if there is too much load on any cq instance, it can relay the request to another less busy instance.

How Dispatcher performs Load-balancing
1)    Performance Statistics – Dispatcher keeps statistics on how fast each instance of cq is responding to a particular url. Based on those metrics, dispatcher determines which instance of cq will fetch the quickest response for any request and relays the request to that cq instance.
2)    Sticky Connections – when a user session is established, then all incoming requests from that user should be served by the same cq instance, because other cq instances cannot recognize the user session and generate personalized pages for him. Dispatcher makes sure all requests for user session are served from the same cq instance.

 Q)    How is Content Moved from author to publish instance? 

The content once published is moved from author instance to publish instance using replication agent.

Replication agent has following responsibilities:

1. Move content from author to publish instance.
2. If any content is updated, then it flushes the older content from dispatcher cache.

A development environment can contain multiple cq-author and multiple cq-publish instances, therefore an author instace can be configured to have many replication agents. Each of which will replicate the content in 1 or more publish instances.

When a request is made from user to publish any content, then the replication agent packages the content and places it in a replication queue.

A Listener servlet in publish instance receives the content package and updates the content in publish instance. The default listener servlet in publish instance is “http://localhost:4503/bin/recieve” .

Q) How is content moved from publish instance to author instance?

Consider the scenario where your website is having a blog or a forum, and the users are posting comments in the blog. Then that comments will only be in publish instance. The content is moved from publish instance to author instance using reverse replication and the job is done by reverse replication agent.

The reverse replication agent places any content updates in an outbox configured in publish instance. The replication listeners in author environment keep listening to the publish outbox and whenever any content is placed in publish outbox, the listeners update the content in author instance.

Q) What is persistence manager in cq5?

CQ uses persistence manager to save the content to a persistent storage like file system or a database.

By default the crx content is stored using Tar Persistence manager. It stores the content to file-system in standard linux archive files called tar.

if you want to store the repository content in a database, then you can configure cq5 to use a database persistence manager.

Q)     What is REST? What is a RESTful Framework?

REST stands for Representational State Transfer.

According to the REST architecture, there are 6 constrainst which should be followed:

Client–server

A uniform interface separates clients from servers. This separation of concerns means that, for example, clients are not concerned with data storage, which remains internal to each server, so that the portability of client code is improved. Servers are not concerned with the user interface or user state, so that servers can be simpler and more scalable. Servers and clients may also be replaced and developed independently, as long as the interface between them is not altered.

Stateless

The client–server communication is further constrained by no client context being stored on the server between requests. Each request from any client contains all of the information necessary to service the request, and any session state is held in the client.

Cacheable

As on the World Wide Web, clients can cache responses. Responses must therefore, implicitly or explicitly, define themselves as cacheable, or not, to prevent clients reusing stale or inappropriate data in response to further requests. Well-managed caching partially or completely eliminates some client–server interactions, further improving scalability and performance.

Layered system

A client cannot ordinarily tell whether it is connected directly to the end server, or to an intermediary along the way. Intermediary servers may improve system scalability by enabling load-balancing and by providing shared caches. They may also enforce security policies.

Code on demand (optional)

Servers are able temporarily to extend or customize the functionality of a client by the transfer of executable code. Examples of this may include compiled components such as Java appletsand client-side scripts such as JavaScript.

Uniform interface

The uniform interface between clients and servers, discussed below, simplifies and decouples the architecture, which enables each part to evolve independently. The four guiding principles of this interface are detailed below.