001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.template;
016    
017    import com.liferay.portal.kernel.cache.MultiVMPoolUtil;
018    import com.liferay.portal.kernel.cache.PortalCache;
019    import com.liferay.portal.kernel.cache.SingleVMPoolUtil;
020    import com.liferay.portal.kernel.io.unsync.UnsyncStringWriter;
021    import com.liferay.portal.kernel.template.StringTemplateResource;
022    import com.liferay.portal.kernel.template.TemplateConstants;
023    import com.liferay.portal.kernel.template.TemplateException;
024    import com.liferay.portal.kernel.template.TemplateResource;
025    import com.liferay.portal.kernel.template.TemplateResourceLoader;
026    import com.liferay.portal.kernel.template.URLTemplateResource;
027    import com.liferay.portal.kernel.util.StringBundler;
028    import com.liferay.portal.kernel.util.StringPool;
029    
030    import java.io.Serializable;
031    import java.io.Writer;
032    
033    import java.util.Map;
034    
035    /**
036     * @author Miroslav Ligas
037     */
038    public abstract class AbstractSingleResourceTemplate extends AbstractTemplate {
039    
040            public AbstractSingleResourceTemplate(
041                    TemplateResource templateResource,
042                    TemplateResource errorTemplateResource, Map<String, Object> context,
043                    TemplateContextHelper templateContextHelper, String templateManagerName,
044                    long interval) {
045    
046                    super(
047                            errorTemplateResource, context, templateContextHelper,
048                            templateManagerName);
049    
050                    if (templateResource == null) {
051                            throw new IllegalArgumentException("Template resource is null");
052                    }
053    
054                    this.templateResource = templateResource;
055    
056                    if (interval != 0) {
057                            cacheTemplateResource(templateManagerName);
058                    }
059            }
060    
061            @Override
062            public void doProcessTemplate(Writer writer) throws Exception {
063                    UnsyncStringWriter unsyncStringWriter = new UnsyncStringWriter();
064    
065                    put(TemplateConstants.WRITER, unsyncStringWriter);
066    
067                    processTemplate(templateResource, unsyncStringWriter);
068    
069                    StringBundler sb = unsyncStringWriter.getStringBundler();
070    
071                    sb.writeTo(writer);
072            }
073    
074            @Override
075            public void processTemplate(Writer writer) throws TemplateException {
076                    if (errorTemplateResource == null) {
077                            try {
078                                    processTemplate(templateResource, writer);
079    
080                                    return;
081                            }
082                            catch (Exception e) {
083                                    throw new TemplateException(
084                                            "Unable to process template " +
085                                                    templateResource.getTemplateId(),
086                                            e);
087                            }
088                    }
089    
090                    _write(writer);
091            }
092    
093            protected void cacheTemplateResource(String templateManagerName) {
094                    if (templateManagerName.equals(TemplateConstants.LANG_TYPE_VM)) {
095                            return;
096                    }
097    
098                    if (!(templateResource instanceof CacheTemplateResource) &&
099                            !(templateResource instanceof StringTemplateResource)) {
100    
101                            templateResource = new CacheTemplateResource(templateResource);
102                    }
103    
104                    String portalCacheName = TemplateResourceLoader.class.getName();
105    
106                    portalCacheName = portalCacheName.concat(StringPool.PERIOD).concat(
107                            templateManagerName);
108    
109                    PortalCache<String, Serializable> portalCache = getPortalCache(
110                            templateResource, portalCacheName);
111    
112                    Object object = portalCache.get(templateResource.getTemplateId());
113    
114                    if ((object == null) || !templateResource.equals(object)) {
115                            portalCache.put(templateResource.getTemplateId(), templateResource);
116                    }
117    
118                    if (errorTemplateResource == null) {
119                            return;
120                    }
121    
122                    if (templateManagerName.equals(TemplateConstants.LANG_TYPE_VM)) {
123                            return;
124                    }
125    
126                    if (!(errorTemplateResource instanceof CacheTemplateResource) &&
127                            !(errorTemplateResource instanceof StringTemplateResource)) {
128    
129                            errorTemplateResource = new CacheTemplateResource(
130                                    errorTemplateResource);
131                    }
132    
133                    portalCache = getPortalCache(errorTemplateResource, portalCacheName);
134    
135                    object = portalCache.get(errorTemplateResource.getTemplateId());
136    
137                    if ((object == null) || !errorTemplateResource.equals(object)) {
138                            portalCache.put(
139                                    errorTemplateResource.getTemplateId(), errorTemplateResource);
140                    }
141            }
142    
143            protected PortalCache<String, Serializable> getPortalCache(
144                    TemplateResource templateResource, String portalCacheName) {
145    
146                    if (!(templateResource instanceof CacheTemplateResource)) {
147                            return MultiVMPoolUtil.getPortalCache(portalCacheName);
148                    }
149    
150                    CacheTemplateResource cacheTemplateResource =
151                            (CacheTemplateResource)templateResource;
152    
153                    TemplateResource innerTemplateResource =
154                            cacheTemplateResource.getInnerTemplateResource();
155    
156                    if (innerTemplateResource instanceof URLTemplateResource) {
157                            return SingleVMPoolUtil.getPortalCache(portalCacheName);
158                    }
159    
160                    return MultiVMPoolUtil.getPortalCache(portalCacheName);
161            }
162    
163            protected abstract void processTemplate(
164                            TemplateResource templateResource, Writer writer)
165                    throws Exception;
166    
167            protected TemplateResource templateResource;
168    
169    }