001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portal.deploy.hot;
016    
017    import com.liferay.portal.captcha.CaptchaImpl;
018    import com.liferay.portal.events.EventsProcessorUtil;
019    import com.liferay.portal.kernel.bean.BeanLocatorException;
020    import com.liferay.portal.kernel.bean.ClassLoaderBeanHandler;
021    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
022    import com.liferay.portal.kernel.bean.PortletBeanLocatorUtil;
023    import com.liferay.portal.kernel.captcha.Captcha;
024    import com.liferay.portal.kernel.captcha.CaptchaUtil;
025    import com.liferay.portal.kernel.configuration.Configuration;
026    import com.liferay.portal.kernel.configuration.ConfigurationFactoryUtil;
027    import com.liferay.portal.kernel.deploy.DeployManagerUtil;
028    import com.liferay.portal.kernel.deploy.auto.AutoDeployDir;
029    import com.liferay.portal.kernel.deploy.auto.AutoDeployListener;
030    import com.liferay.portal.kernel.deploy.auto.AutoDeployUtil;
031    import com.liferay.portal.kernel.deploy.hot.BaseHotDeployListener;
032    import com.liferay.portal.kernel.deploy.hot.HotDeployEvent;
033    import com.liferay.portal.kernel.deploy.hot.HotDeployException;
034    import com.liferay.portal.kernel.deploy.hot.HotDeployListener;
035    import com.liferay.portal.kernel.deploy.hot.HotDeployUtil;
036    import com.liferay.portal.kernel.events.Action;
037    import com.liferay.portal.kernel.events.InvokerAction;
038    import com.liferay.portal.kernel.events.InvokerSessionAction;
039    import com.liferay.portal.kernel.events.InvokerSimpleAction;
040    import com.liferay.portal.kernel.events.SessionAction;
041    import com.liferay.portal.kernel.events.SimpleAction;
042    import com.liferay.portal.kernel.format.PhoneNumberFormat;
043    import com.liferay.portal.kernel.format.PhoneNumberFormatUtil;
044    import com.liferay.portal.kernel.format.PhoneNumberFormatWrapper;
045    import com.liferay.portal.kernel.language.LanguageUtil;
046    import com.liferay.portal.kernel.lock.LockListener;
047    import com.liferay.portal.kernel.lock.LockListenerRegistryUtil;
048    import com.liferay.portal.kernel.log.Log;
049    import com.liferay.portal.kernel.log.LogFactoryUtil;
050    import com.liferay.portal.kernel.log.SanitizerLogWrapper;
051    import com.liferay.portal.kernel.plugin.PluginPackage;
052    import com.liferay.portal.kernel.sanitizer.Sanitizer;
053    import com.liferay.portal.kernel.sanitizer.SanitizerUtil;
054    import com.liferay.portal.kernel.search.Indexer;
055    import com.liferay.portal.kernel.search.IndexerPostProcessor;
056    import com.liferay.portal.kernel.search.IndexerRegistryUtil;
057    import com.liferay.portal.kernel.security.pacl.PACLConstants;
058    import com.liferay.portal.kernel.security.pacl.permission.PortalHookPermission;
059    import com.liferay.portal.kernel.servlet.DirectServletRegistryUtil;
060    import com.liferay.portal.kernel.servlet.LiferayFilter;
061    import com.liferay.portal.kernel.servlet.LiferayFilterTracker;
062    import com.liferay.portal.kernel.servlet.ServletContextPool;
063    import com.liferay.portal.kernel.servlet.TryFilter;
064    import com.liferay.portal.kernel.servlet.TryFinallyFilter;
065    import com.liferay.portal.kernel.servlet.WrapHttpServletRequestFilter;
066    import com.liferay.portal.kernel.servlet.WrapHttpServletResponseFilter;
067    import com.liferay.portal.kernel.servlet.filters.invoker.FilterMapping;
068    import com.liferay.portal.kernel.servlet.filters.invoker.InvokerFilterConfig;
069    import com.liferay.portal.kernel.servlet.filters.invoker.InvokerFilterHelper;
070    import com.liferay.portal.kernel.servlet.taglib.FileAvailabilityUtil;
071    import com.liferay.portal.kernel.struts.StrutsAction;
072    import com.liferay.portal.kernel.struts.StrutsPortletAction;
073    import com.liferay.portal.kernel.upgrade.UpgradeException;
074    import com.liferay.portal.kernel.util.ArrayUtil;
075    import com.liferay.portal.kernel.util.CharPool;
076    import com.liferay.portal.kernel.util.FileUtil;
077    import com.liferay.portal.kernel.util.GetterUtil;
078    import com.liferay.portal.kernel.util.HttpUtil;
079    import com.liferay.portal.kernel.util.InstanceFactory;
080    import com.liferay.portal.kernel.util.ListUtil;
081    import com.liferay.portal.kernel.util.LocaleUtil;
082    import com.liferay.portal.kernel.util.PortalClassLoaderUtil;
083    import com.liferay.portal.kernel.util.PropertiesUtil;
084    import com.liferay.portal.kernel.util.PropsKeys;
085    import com.liferay.portal.kernel.util.ProxyUtil;
086    import com.liferay.portal.kernel.util.ReflectionUtil;
087    import com.liferay.portal.kernel.util.SetUtil;
088    import com.liferay.portal.kernel.util.StringBundler;
089    import com.liferay.portal.kernel.util.StringPool;
090    import com.liferay.portal.kernel.util.StringUtil;
091    import com.liferay.portal.kernel.util.UniqueList;
092    import com.liferay.portal.kernel.util.Validator;
093    import com.liferay.portal.kernel.xml.Document;
094    import com.liferay.portal.kernel.xml.Element;
095    import com.liferay.portal.kernel.xml.UnsecureSAXReaderUtil;
096    import com.liferay.portal.language.LanguageResources;
097    import com.liferay.portal.model.BaseModel;
098    import com.liferay.portal.model.LayoutConstants;
099    import com.liferay.portal.model.ModelListener;
100    import com.liferay.portal.model.Release;
101    import com.liferay.portal.repository.util.RepositoryFactory;
102    import com.liferay.portal.repository.util.RepositoryFactoryImpl;
103    import com.liferay.portal.repository.util.RepositoryFactoryUtil;
104    import com.liferay.portal.sanitizer.SanitizerImpl;
105    import com.liferay.portal.security.auth.AuthFailure;
106    import com.liferay.portal.security.auth.AuthPipeline;
107    import com.liferay.portal.security.auth.AuthToken;
108    import com.liferay.portal.security.auth.AuthTokenUtil;
109    import com.liferay.portal.security.auth.AuthTokenWhitelistUtil;
110    import com.liferay.portal.security.auth.AuthTokenWrapper;
111    import com.liferay.portal.security.auth.AuthVerifier;
112    import com.liferay.portal.security.auth.AuthVerifierConfiguration;
113    import com.liferay.portal.security.auth.AuthVerifierPipeline;
114    import com.liferay.portal.security.auth.Authenticator;
115    import com.liferay.portal.security.auth.AutoLogin;
116    import com.liferay.portal.security.auth.CompanyThreadLocal;
117    import com.liferay.portal.security.auth.EmailAddressGenerator;
118    import com.liferay.portal.security.auth.EmailAddressGeneratorFactory;
119    import com.liferay.portal.security.auth.EmailAddressValidator;
120    import com.liferay.portal.security.auth.EmailAddressValidatorFactory;
121    import com.liferay.portal.security.auth.FullNameGenerator;
122    import com.liferay.portal.security.auth.FullNameGeneratorFactory;
123    import com.liferay.portal.security.auth.FullNameValidator;
124    import com.liferay.portal.security.auth.FullNameValidatorFactory;
125    import com.liferay.portal.security.auth.InterruptedPortletRequestWhitelistUtil;
126    import com.liferay.portal.security.auth.ScreenNameGenerator;
127    import com.liferay.portal.security.auth.ScreenNameGeneratorFactory;
128    import com.liferay.portal.security.auth.ScreenNameValidator;
129    import com.liferay.portal.security.auth.ScreenNameValidatorFactory;
130    import com.liferay.portal.security.lang.DoPrivilegedBean;
131    import com.liferay.portal.security.ldap.AttributesTransformer;
132    import com.liferay.portal.security.ldap.AttributesTransformerFactory;
133    import com.liferay.portal.security.membershippolicy.OrganizationMembershipPolicy;
134    import com.liferay.portal.security.membershippolicy.OrganizationMembershipPolicyFactoryImpl;
135    import com.liferay.portal.security.membershippolicy.OrganizationMembershipPolicyFactoryUtil;
136    import com.liferay.portal.security.membershippolicy.RoleMembershipPolicy;
137    import com.liferay.portal.security.membershippolicy.RoleMembershipPolicyFactoryImpl;
138    import com.liferay.portal.security.membershippolicy.RoleMembershipPolicyFactoryUtil;
139    import com.liferay.portal.security.membershippolicy.SiteMembershipPolicy;
140    import com.liferay.portal.security.membershippolicy.SiteMembershipPolicyFactoryImpl;
141    import com.liferay.portal.security.membershippolicy.SiteMembershipPolicyFactoryUtil;
142    import com.liferay.portal.security.membershippolicy.UserGroupMembershipPolicy;
143    import com.liferay.portal.security.membershippolicy.UserGroupMembershipPolicyFactoryImpl;
144    import com.liferay.portal.security.membershippolicy.UserGroupMembershipPolicyFactoryUtil;
145    import com.liferay.portal.security.pwd.PwdToolkitUtil;
146    import com.liferay.portal.security.pwd.Toolkit;
147    import com.liferay.portal.security.pwd.ToolkitWrapper;
148    import com.liferay.portal.service.ReleaseLocalServiceUtil;
149    import com.liferay.portal.service.ServiceWrapper;
150    import com.liferay.portal.service.persistence.BasePersistence;
151    import com.liferay.portal.servlet.filters.autologin.AutoLoginFilter;
152    import com.liferay.portal.servlet.filters.cache.CacheUtil;
153    import com.liferay.portal.spring.aop.ServiceBeanAopCacheManagerUtil;
154    import com.liferay.portal.spring.aop.ServiceBeanAopProxy;
155    import com.liferay.portal.struts.AuthPublicPathRegistry;
156    import com.liferay.portal.struts.StrutsActionRegistryUtil;
157    import com.liferay.portal.upgrade.UpgradeProcessUtil;
158    import com.liferay.portal.util.CustomJspRegistryUtil;
159    import com.liferay.portal.util.JavaScriptBundleUtil;
160    import com.liferay.portal.util.LayoutSettings;
161    import com.liferay.portal.util.PortalInstances;
162    import com.liferay.portal.util.PortalUtil;
163    import com.liferay.portal.util.PropsUtil;
164    import com.liferay.portal.util.PropsValues;
165    import com.liferay.portlet.ControlPanelEntry;
166    import com.liferay.portlet.DefaultControlPanelEntryFactory;
167    import com.liferay.portlet.assetpublisher.util.AssetEntryQueryProcessor;
168    import com.liferay.portlet.assetpublisher.util.AssetPublisherUtil;
169    import com.liferay.portlet.documentlibrary.antivirus.AntivirusScanner;
170    import com.liferay.portlet.documentlibrary.antivirus.AntivirusScannerUtil;
171    import com.liferay.portlet.documentlibrary.antivirus.AntivirusScannerWrapper;
172    import com.liferay.portlet.documentlibrary.store.Store;
173    import com.liferay.portlet.documentlibrary.store.StoreFactory;
174    import com.liferay.portlet.documentlibrary.util.DLProcessor;
175    import com.liferay.portlet.documentlibrary.util.DLProcessorRegistryUtil;
176    
177    import java.io.File;
178    import java.io.InputStream;
179    
180    import java.lang.reflect.Constructor;
181    import java.lang.reflect.Field;
182    import java.lang.reflect.InvocationHandler;
183    
184    import java.net.URL;
185    
186    import java.util.ArrayList;
187    import java.util.HashMap;
188    import java.util.HashSet;
189    import java.util.Iterator;
190    import java.util.List;
191    import java.util.Locale;
192    import java.util.Map;
193    import java.util.Properties;
194    import java.util.Set;
195    
196    import javax.servlet.Filter;
197    import javax.servlet.FilterConfig;
198    import javax.servlet.ServletContext;
199    
200    import org.springframework.aop.TargetSource;
201    import org.springframework.aop.framework.AdvisedSupport;
202    import org.springframework.aop.target.SingletonTargetSource;
203    
204    /**
205     * @author Brian Wing Shun Chan
206     * @author Bruno Farache
207     * @author Wesley Gong
208     * @author Ryan Park
209     * @author Mika Koivisto
210     */
211    public class HookHotDeployListener
212            extends BaseHotDeployListener implements PropsKeys {
213    
214            public static final String[] SUPPORTED_PROPERTIES = {
215                    "admin.default.group.names", "admin.default.role.names",
216                    "admin.default.user.group.names",
217                    "asset.publisher.asset.entry.query.processors",
218                    "asset.publisher.display.styles",
219                    "asset.publisher.query.form.configuration", "auth.forward.by.last.path",
220                    "auth.public.paths", "auth.verifier.pipeline", "auto.deploy.listeners",
221                    "application.startup.events", "auth.failure", "auth.max.failures",
222                    "auth.token.ignore.actions", "auth.token.ignore.origins",
223                    "auth.token.ignore.portlets", "auth.token.impl", "auth.pipeline.post",
224                    "auth.pipeline.pre", "auto.login.hooks",
225                    "captcha.check.portal.create_account", "captcha.engine.impl",
226                    "company.default.locale", "company.default.time.zone",
227                    "company.settings.form.authentication",
228                    "company.settings.form.configuration",
229                    "company.settings.form.identification",
230                    "company.settings.form.miscellaneous",
231                    "control.panel.entry.class.default", "convert.processes",
232                    "default.landing.page.path", "default.regular.color.scheme.id",
233                    "default.regular.theme.id", "default.wap.color.scheme.id",
234                    "default.wap.theme.id", "dl.file.entry.drafts.enabled",
235                    "dl.file.entry.open.in.ms.office.manual.check.in.required",
236                    "dl.file.entry.processors", "dl.repository.impl",
237                    "dl.store.antivirus.enabled", "dl.store.antivirus.impl",
238                    "dl.store.impl", "dockbar.add.portlets",
239                    "field.enable.com.liferay.portal.model.Contact.birthday",
240                    "field.enable.com.liferay.portal.model.Contact.male",
241                    "field.enable.com.liferay.portal.model.Organization.status",
242                    "hot.deploy.listeners", "javascript.fast.load",
243                    "journal.article.form.add", "journal.article.form.translate",
244                    "journal.article.form.update", "layout.form.add", "layout.form.update",
245                    "layout.set.form.update", "layout.static.portlets.all",
246                    "layout.template.cache.enabled", "layout.types",
247                    "layout.user.private.layouts.auto.create",
248                    "layout.user.private.layouts.enabled",
249                    "layout.user.private.layouts.power.user.required",
250                    "layout.user.public.layouts.auto.create",
251                    "layout.user.public.layouts.enabled",
252                    "layout.user.public.layouts.power.user.required",
253                    "ldap.attrs.transformer.impl", "locales", "locales.beta",
254                    "locales.enabled", "lock.listeners",
255                    "login.create.account.allow.custom.password", "login.dialog.disabled",
256                    "login.events.post", "login.events.pre", "login.form.navigation.post",
257                    "login.form.navigation.pre", "logout.events.post", "logout.events.pre",
258                    "mail.hook.impl", "my.sites.show.private.sites.with.no.layouts",
259                    "my.sites.show.public.sites.with.no.layouts",
260                    "my.sites.show.user.private.sites.with.no.layouts",
261                    "my.sites.show.user.public.sites.with.no.layouts",
262                    "organizations.form.add.identification", "organizations.form.add.main",
263                    "organizations.form.add.miscellaneous",
264                    "passwords.passwordpolicytoolkit.generator",
265                    "passwords.passwordpolicytoolkit.static", "phone.number.format.impl",
266                    "phone.number.format.international.regexp",
267                    "phone.number.format.usa.regexp",
268                    "portlet.add.default.resource.check.enabled",
269                    "portlet.add.default.resource.check.whitelist",
270                    "portlet.add.default.resource.check.whitelist.actions",
271                    "rss.feeds.enabled", "sanitizer.impl", "servlet.session.create.events",
272                    "servlet.session.destroy.events", "servlet.service.events.post",
273                    "servlet.service.events.pre", "session.max.allowed",
274                    "session.phishing.protected.attributes", "session.store.password",
275                    "sites.form.add.advanced", "sites.form.add.main", "sites.form.add.seo",
276                    "sites.form.update.advanced", "sites.form.update.main",
277                    "sites.form.update.seo", "social.activity.sets.bundling.enabled",
278                    "social.activity.sets.enabled", "social.activity.sets.selector",
279                    "social.bookmark.*", "staging.xstream.class.whitelist",
280                    "terms.of.use.required", "theme.css.fast.load",
281                    "theme.images.fast.load", "theme.jsp.override.enabled",
282                    "theme.loader.new.theme.id.on.import", "theme.portlet.decorate.default",
283                    "theme.portlet.sharing.default", "theme.shortcut.icon", "time.zones",
284                    "upgrade.processes", "user.notification.event.confirmation.enabled",
285                    "users.email.address.generator", "users.email.address.validator",
286                    "users.email.address.required", "users.form.add.identification",
287                    "users.form.add.main", "users.form.add.miscellaneous",
288                    "users.form.my.account.identification", "users.form.my.account.main",
289                    "users.form.my.account.miscellaneous",
290                    "users.form.update.identification", "users.form.update.main",
291                    "users.form.update.miscellaneous", "users.full.name.generator",
292                    "users.full.name.validator", "users.image.max.height",
293                    "users.image.max.width", "users.screen.name.always.autogenerate",
294                    "users.screen.name.generator", "users.screen.name.validator",
295                    "value.object.listener.*"
296            };
297    
298            public HookHotDeployListener() {
299                    for (String key : _PROPS_VALUES_MERGE_STRING_ARRAY) {
300                            _mergeStringArraysContainerMap.put(
301                                    key, new MergeStringArraysContainer(key));
302                    }
303    
304                    for (String key : _PROPS_VALUES_OVERRIDE_STRING_ARRAY) {
305                            _overrideStringArraysContainerMap.put(
306                                    key, new OverrideStringArraysContainer(key));
307                    }
308            }
309    
310            @Override
311            public void invokeDeploy(HotDeployEvent hotDeployEvent)
312                    throws HotDeployException {
313    
314                    try {
315                            doInvokeDeploy(hotDeployEvent);
316                    }
317                    catch (Throwable t) {
318                            throwHotDeployException(
319                                    hotDeployEvent,
320                                    "Error registering hook for " +
321                                            hotDeployEvent.getServletContextName(),
322                                    t);
323                    }
324            }
325    
326            @Override
327            public void invokeUndeploy(HotDeployEvent hotDeployEvent)
328                    throws HotDeployException {
329    
330                    try {
331                            doInvokeUndeploy(hotDeployEvent);
332                    }
333                    catch (Throwable t) {
334                            throwHotDeployException(
335                                    hotDeployEvent,
336                                    "Error unregistering hook for " +
337                                            hotDeployEvent.getServletContextName(),
338                                    t);
339                    }
340            }
341    
342            protected boolean checkPermission(
343                    String name, ClassLoader portletClassLoader, Object subject,
344                    String message) {
345    
346                    try {
347                            PortalHookPermission.checkPermission(
348                                    name, portletClassLoader, subject);
349                    }
350                    catch (SecurityException se) {
351                            if (_log.isInfoEnabled()) {
352                                    _log.info(message);
353                            }
354    
355                            return false;
356                    }
357    
358                    return true;
359            }
360    
361            protected boolean containsKey(Properties portalProperties, String key) {
362                    if (_log.isDebugEnabled()) {
363                            return true;
364                    }
365                    else {
366                            return portalProperties.containsKey(key);
367                    }
368            }
369    
370            protected void destroyCustomJspBag(
371                            String servletContextName, CustomJspBag customJspBag)
372                    throws Exception {
373    
374                    String customJspDir = customJspBag.getCustomJspDir();
375                    boolean customJspGlobal = customJspBag.isCustomJspGlobal();
376                    List<String> customJsps = customJspBag.getCustomJsps();
377    
378                    String portalWebDir = PortalUtil.getPortalWebDir();
379    
380                    for (String customJsp : customJsps) {
381                            int pos = customJsp.indexOf(customJspDir);
382    
383                            String portalJsp = customJsp.substring(pos + customJspDir.length());
384    
385                            if (customJspGlobal) {
386                                    File portalJspFile = new File(portalWebDir + portalJsp);
387                                    File portalJspBackupFile = getPortalJspBackupFile(
388                                            portalJspFile);
389    
390                                    if (portalJspBackupFile.exists()) {
391                                            FileUtil.copyFile(portalJspBackupFile, portalJspFile);
392    
393                                            portalJspBackupFile.delete();
394                                    }
395                                    else if (portalJspFile.exists()) {
396                                            portalJspFile.delete();
397                                    }
398                            }
399                            else {
400                                    portalJsp = CustomJspRegistryUtil.getCustomJspFileName(
401                                            servletContextName, portalJsp);
402    
403                                    File portalJspFile = new File(portalWebDir + portalJsp);
404    
405                                    if (portalJspFile.exists()) {
406                                            portalJspFile.delete();
407                                    }
408                            }
409                    }
410    
411                    if (!customJspGlobal) {
412                            CustomJspRegistryUtil.unregisterServletContextName(
413                                    servletContextName);
414                    }
415            }
416    
417            protected void destroyPortalProperties(
418                            String servletContextName, Properties portalProperties)
419                    throws Exception {
420    
421                    PropsUtil.removeProperties(portalProperties);
422    
423                    if (_log.isDebugEnabled() && portalProperties.containsKey(LOCALES)) {
424                            _log.debug(
425                                    "Portlet locales " + portalProperties.getProperty(LOCALES));
426                            _log.debug("Original locales " + PropsUtil.get(LOCALES));
427                            _log.debug(
428                                    "Original locales array length " +
429                                            PropsUtil.getArray(LOCALES).length);
430                    }
431    
432                    resetPortalProperties(servletContextName, portalProperties, false);
433    
434                    if (portalProperties.containsKey(
435                                    PropsKeys.ASSET_PUBLISHER_ASSET_ENTRY_QUERY_PROCESSORS)) {
436    
437                            String[] assetQueryProcessorClassNames = StringUtil.split(
438                                    portalProperties.getProperty(
439                                            PropsKeys.ASSET_PUBLISHER_ASSET_ENTRY_QUERY_PROCESSORS));
440    
441                            for (String assetQueryProcessorClassName :
442                                            assetQueryProcessorClassNames) {
443    
444                                    AssetPublisherUtil.unregisterAssetQueryProcessor(
445                                            assetQueryProcessorClassName);
446    
447                                    if (_log.isDebugEnabled()) {
448                                            _log.debug(
449                                                    "Unregistered asset query processor " +
450                                                            assetQueryProcessorClassName);
451                                    }
452                            }
453                    }
454    
455                    if (portalProperties.containsKey(PropsKeys.AUTH_TOKEN_IMPL)) {
456                            AuthTokenWrapper authTokenWrapper =
457                                    (AuthTokenWrapper)AuthTokenUtil.getAuthToken();
458    
459                            authTokenWrapper.setAuthToken(null);
460                    }
461    
462                    if (portalProperties.containsKey(PropsKeys.CAPTCHA_ENGINE_IMPL)) {
463                            CaptchaImpl captchaImpl = null;
464    
465                            Captcha captcha = CaptchaUtil.getCaptcha();
466    
467                            if (captcha instanceof DoPrivilegedBean) {
468                                    DoPrivilegedBean doPrivilegedBean = (DoPrivilegedBean)captcha;
469    
470                                    captchaImpl = (CaptchaImpl)doPrivilegedBean.getActualBean();
471                            }
472                            else {
473                                    captchaImpl = (CaptchaImpl)captcha;
474                            }
475    
476                            captchaImpl.setCaptcha(null);
477                    }
478    
479                    if (portalProperties.containsKey(
480                                    PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS)) {
481    
482                            DefaultControlPanelEntryFactory.setInstance(null);
483                    }
484    
485                    if (portalProperties.containsKey(PropsKeys.DL_FILE_ENTRY_PROCESSORS)) {
486                            DLFileEntryProcessorContainer dlFileEntryProcessorContainer =
487                                    _dlFileEntryProcessorContainerMap.remove(servletContextName);
488    
489                            dlFileEntryProcessorContainer.unregisterDLProcessors();
490                    }
491    
492                    if (portalProperties.containsKey(PropsKeys.DL_REPOSITORY_IMPL)) {
493                            DLRepositoryContainer dlRepositoryContainer =
494                                    _dlRepositoryContainerMap.remove(servletContextName);
495    
496                            dlRepositoryContainer.unregisterRepositoryFactories();
497                    }
498    
499                    if (portalProperties.containsKey(PropsKeys.DL_STORE_ANTIVIRUS_IMPL)) {
500                            AntivirusScannerWrapper antivirusScannerWrapper =
501                                    (AntivirusScannerWrapper)
502                                            AntivirusScannerUtil.getAntivirusScanner();
503    
504                            antivirusScannerWrapper.setAntivirusScanner(null);
505                    }
506    
507                    if (portalProperties.containsKey(PropsKeys.DL_STORE_IMPL)) {
508                            StoreFactory.setInstance(null);
509                    }
510    
511                    if (portalProperties.containsKey(
512                                    PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL)) {
513    
514                            AttributesTransformerFactory.setInstance(null);
515                    }
516    
517                    if (portalProperties.containsKey(LOCK_LISTENERS)) {
518                            LockListenerContainer lockListenerContainer =
519                                    _lockListenerContainerMap.remove(servletContextName);
520    
521                            if (lockListenerContainer != null) {
522                                    lockListenerContainer.unregisterLockListeners();
523                            }
524                    }
525    
526                    if (portalProperties.containsKey(PropsKeys.MAIL_HOOK_IMPL)) {
527                            com.liferay.mail.util.HookFactory.setInstance(null);
528                    }
529    
530                    if (portalProperties.containsKey(
531                                    PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS)) {
532    
533                            OrganizationMembershipPolicyFactoryImpl
534                                    organizationMembershipPolicyFactoryImpl =
535                                            (OrganizationMembershipPolicyFactoryImpl)
536                                                    OrganizationMembershipPolicyFactoryUtil.
537                                                            getOrganizationMembershipPolicyFactory();
538    
539                            organizationMembershipPolicyFactoryImpl.
540                                    setOrganizationMembershipPolicy(null);
541                    }
542    
543                    if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_ROLES)) {
544                            RoleMembershipPolicyFactoryImpl roleMembershipPolicyFactoryImpl =
545                                    (RoleMembershipPolicyFactoryImpl)
546                                            RoleMembershipPolicyFactoryUtil.
547                                                    getRoleMembershipPolicyFactory();
548    
549                            roleMembershipPolicyFactoryImpl.setRoleMembershipPolicy(null);
550                    }
551    
552                    if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_SITES)) {
553                            SiteMembershipPolicyFactoryImpl siteMembershipPolicyFactoryImpl =
554                                    (SiteMembershipPolicyFactoryImpl)
555                                            SiteMembershipPolicyFactoryUtil.
556                                                    getSiteMembershipPolicyFactory();
557    
558                            siteMembershipPolicyFactoryImpl.setSiteMembershipPolicy(null);
559                    }
560    
561                    if (portalProperties.containsKey(
562                                    PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS)) {
563    
564                            UserGroupMembershipPolicyFactoryImpl
565                                    userGroupMembershipPolicyFactoryImpl =
566                                            (UserGroupMembershipPolicyFactoryImpl)
567                                                    UserGroupMembershipPolicyFactoryUtil.
568                                                            getUserGroupMembershipPolicyFactory();
569    
570                            userGroupMembershipPolicyFactoryImpl.setUserGroupMembershipPolicy(
571                                    null);
572                    }
573    
574                    if (portalProperties.containsKey(PropsKeys.PASSWORDS_TOOLKIT)) {
575                            ToolkitWrapper toolkitWrapper =
576                                    (ToolkitWrapper)PwdToolkitUtil.getToolkit();
577    
578                            toolkitWrapper.setToolkit(null);
579                    }
580    
581                    if (portalProperties.containsKey(PropsKeys.PHONE_NUMBER_FORMAT_IMPL)) {
582                            PhoneNumberFormatWrapper phoneNumberFormatWrapper =
583                                    (PhoneNumberFormatWrapper)
584                                            PhoneNumberFormatUtil.getPhoneNumberFormat();
585    
586                            phoneNumberFormatWrapper.setPhoneNumberFormat(null);
587                    }
588    
589                    if (portalProperties.containsKey(PropsKeys.SANITIZER_IMPL)) {
590                            SanitizerContainer sanitizerContainer =
591                                    _sanitizerContainerMap.remove(servletContextName);
592    
593                            if (sanitizerContainer != null) {
594                                    sanitizerContainer.unregisterSanitizers();
595                            }
596                    }
597    
598                    if (portalProperties.containsKey(
599                                    PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR)) {
600    
601                            EmailAddressGeneratorFactory.setInstance(null);
602                    }
603    
604                    if (portalProperties.containsKey(
605                                    PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR)) {
606    
607                            EmailAddressValidatorFactory.setInstance(null);
608                    }
609    
610                    if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_GENERATOR)) {
611                            FullNameGeneratorFactory.setInstance(null);
612                    }
613    
614                    if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_VALIDATOR)) {
615                            FullNameValidatorFactory.setInstance(null);
616                    }
617    
618                    if (portalProperties.containsKey(
619                                    PropsKeys.USERS_SCREEN_NAME_GENERATOR)) {
620    
621                            ScreenNameGeneratorFactory.setInstance(null);
622                    }
623    
624                    if (portalProperties.containsKey(
625                                    PropsKeys.USERS_SCREEN_NAME_VALIDATOR)) {
626    
627                            ScreenNameValidatorFactory.setInstance(null);
628                    }
629    
630                    Set<String> liferayFilterClassNames =
631                            LiferayFilterTracker.getClassNames();
632    
633                    for (String liferayFilterClassName : liferayFilterClassNames) {
634                            if (!portalProperties.containsKey(liferayFilterClassName)) {
635                                    continue;
636                            }
637    
638                            boolean filterEnabled = GetterUtil.getBoolean(
639                                    PropsUtil.get(liferayFilterClassName));
640    
641                            Set<LiferayFilter> liferayFilters =
642                                    LiferayFilterTracker.getLiferayFilters(liferayFilterClassName);
643    
644                            for (LiferayFilter liferayFilter : liferayFilters) {
645                                    liferayFilter.setFilterEnabled(filterEnabled);
646                            }
647                    }
648            }
649    
650            protected void destroyServices(String servletContextName) throws Exception {
651                    Map<String, ServiceBag> serviceBags = _servicesContainer._serviceBags;
652    
653                    for (Map.Entry<String, ServiceBag> entry : serviceBags.entrySet()) {
654                            String serviceType = entry.getKey();
655                            ServiceBag serviceBag = entry.getValue();
656    
657                            Map<String, List<ServiceConstructor>> serviceConstructors =
658                                    serviceBag._serviceConstructors;
659    
660                            if (serviceConstructors.remove(servletContextName) == null) {
661                                    continue;
662                            }
663    
664                            Object serviceProxy = PortalBeanLocatorUtil.locate(serviceType);
665    
666                            AdvisedSupport advisedSupport =
667                                    ServiceBeanAopProxy.getAdvisedSupport(serviceProxy);
668    
669                            Object previousService = serviceBag.getCustomService();
670    
671                            TargetSource previousTargetSource = new SingletonTargetSource(
672                                    previousService);
673    
674                            advisedSupport.setTargetSource(previousTargetSource);
675                    }
676            }
677    
678            protected void doInvokeDeploy(HotDeployEvent hotDeployEvent)
679                    throws Exception {
680    
681                    ServletContext servletContext = hotDeployEvent.getServletContext();
682    
683                    String servletContextName = servletContext.getServletContextName();
684    
685                    if (_log.isDebugEnabled()) {
686                            _log.debug("Invoking deploy for " + servletContextName);
687                    }
688    
689                    String xml = HttpUtil.URLtoString(
690                            servletContext.getResource("/WEB-INF/liferay-hook.xml"));
691    
692                    if (xml == null) {
693                            return;
694                    }
695    
696                    if (isRTLHook(hotDeployEvent.getPluginPackage())) {
697                            if (_log.isInfoEnabled()) {
698                                    _log.info(
699                                            "Skipping RTL hook since it is now part of the portal");
700                            }
701    
702                            HotDeployUtil.fireUndeployEvent(
703                                    new HotDeployEvent(
704                                            servletContext, hotDeployEvent.getContextClassLoader()));
705    
706                            return;
707                    }
708    
709                    if (_log.isInfoEnabled()) {
710                            _log.info("Registering hook for " + servletContextName);
711                    }
712    
713                    _servletContextNames.add(servletContextName);
714    
715                    Document document = UnsecureSAXReaderUtil.read(xml, true);
716    
717                    Element rootElement = document.getRootElement();
718    
719                    ClassLoader portletClassLoader = hotDeployEvent.getContextClassLoader();
720    
721                    initPortalProperties(
722                            servletContextName, portletClassLoader, rootElement);
723    
724                    initLanguageProperties(
725                            servletContextName, portletClassLoader, rootElement);
726    
727                    try {
728                            initCustomJspDir(
729                                    servletContext, servletContextName, portletClassLoader,
730                                    hotDeployEvent.getPluginPackage(), rootElement);
731                    }
732                    catch (DuplicateCustomJspException dcje) {
733                            if (_log.isWarnEnabled()) {
734                                    _log.warn(servletContextName + " will be undeployed");
735                            }
736    
737                            HotDeployUtil.fireUndeployEvent(
738                                    new HotDeployEvent(servletContext, portletClassLoader));
739    
740                            DeployManagerUtil.undeploy(servletContextName);
741    
742                            return;
743                    }
744    
745                    initIndexerPostProcessors(
746                            servletContextName, portletClassLoader, rootElement);
747    
748                    List<Element> serviceElements = rootElement.elements("service");
749    
750                    for (Element serviceElement : serviceElements) {
751                            String serviceType = serviceElement.elementText("service-type");
752                            String serviceImpl = serviceElement.elementText("service-impl");
753    
754                            if (!checkPermission(
755                                            PACLConstants.PORTAL_HOOK_PERMISSION_SERVICE,
756                                            portletClassLoader, serviceType,
757                                            "Rejecting service " + serviceImpl)) {
758    
759                                    continue;
760                            }
761    
762                            Class<?> serviceTypeClass = portletClassLoader.loadClass(
763                                    serviceType);
764                            Class<?> serviceImplClass = portletClassLoader.loadClass(
765                                    serviceImpl);
766    
767                            Constructor<?> serviceImplConstructor =
768                                    serviceImplClass.getConstructor(
769                                            new Class<?>[] {serviceTypeClass});
770    
771                            Object serviceProxy = PortalBeanLocatorUtil.locate(serviceType);
772    
773                            if (ProxyUtil.isProxyClass(serviceProxy.getClass())) {
774                                    initServices(
775                                            servletContextName, portletClassLoader, serviceType,
776                                            serviceTypeClass, serviceImplConstructor, serviceProxy);
777                            }
778                            else {
779                                    _log.error(
780                                            "Service hooks require Spring to be configured to use " +
781                                                    "JdkDynamicProxy and will not work with CGLIB");
782                            }
783                    }
784    
785                    initServletFilters(
786                            servletContext, servletContextName, portletClassLoader,
787                            rootElement);
788    
789                    initStrutsActions(servletContextName, portletClassLoader, rootElement);
790    
791                    // Begin backwards compatibility for 5.1.0
792    
793                    ModelListenersContainer modelListenersContainer =
794                            _modelListenersContainerMap.get(servletContextName);
795    
796                    if (modelListenersContainer == null) {
797                            modelListenersContainer = new ModelListenersContainer();
798    
799                            _modelListenersContainerMap.put(
800                                    servletContextName, modelListenersContainer);
801                    }
802    
803                    List<Element> modelListenerElements = rootElement.elements(
804                            "model-listener");
805    
806                    for (Element modelListenerElement : modelListenerElements) {
807                            String modelName = modelListenerElement.elementText("model-name");
808                            String modelListenerClassName = modelListenerElement.elementText(
809                                    "model-listener-class");
810    
811                            ModelListener<BaseModel<?>> modelListener = initModelListener(
812                                    servletContextName, portletClassLoader, modelName,
813                                    modelListenerClassName);
814    
815                            if (modelListener != null) {
816                                    modelListenersContainer.registerModelListener(
817                                            modelName, modelListener);
818                            }
819                    }
820    
821                    EventsContainer eventsContainer = _eventsContainerMap.get(
822                            servletContextName);
823    
824                    if (eventsContainer == null) {
825                            eventsContainer = new EventsContainer();
826    
827                            _eventsContainerMap.put(servletContextName, eventsContainer);
828                    }
829    
830                    List<Element> eventElements = rootElement.elements("event");
831    
832                    for (Element eventElement : eventElements) {
833                            String eventName = eventElement.elementText("event-type");
834                            String eventClassName = eventElement.elementText("event-class");
835    
836                            Object obj = initEvent(
837                                    eventName, eventClassName, portletClassLoader);
838    
839                            if (obj != null) {
840                                    eventsContainer.registerEvent(eventName, obj);
841                            }
842                    }
843    
844                    // End backwards compatibility for 5.1.0
845    
846                    registerClpMessageListeners(servletContext, portletClassLoader);
847    
848                    DirectServletRegistryUtil.clearServlets();
849                    FileAvailabilityUtil.reset();
850    
851                    if (_log.isInfoEnabled()) {
852                            _log.info(
853                                    "Hook for " + servletContextName + " is available for use");
854                    }
855            }
856    
857            protected void doInvokeUndeploy(HotDeployEvent hotDeployEvent)
858                    throws Exception {
859    
860                    ServletContext servletContext = hotDeployEvent.getServletContext();
861    
862                    String servletContextName = servletContext.getServletContextName();
863    
864                    if (_log.isDebugEnabled()) {
865                            _log.debug("Invoking undeploy for " + servletContextName);
866                    }
867    
868                    if (!_servletContextNames.remove(servletContextName)) {
869                            return;
870                    }
871    
872                    AuthenticatorsContainer authenticatorsContainer =
873                            _authenticatorsContainerMap.remove(servletContextName);
874    
875                    if (authenticatorsContainer != null) {
876                            authenticatorsContainer.unregisterAuthenticators();
877                    }
878    
879                    AuthFailuresContainer authFailuresContainer =
880                            _authFailuresContainerMap.remove(servletContextName);
881    
882                    if (authFailuresContainer != null) {
883                            authFailuresContainer.unregisterAuthFailures();
884                    }
885    
886                    AuthPublicPathsContainer authPublicPathsContainer =
887                            _authPublicPathsContainerMap.remove(servletContextName);
888    
889                    if (authPublicPathsContainer != null) {
890                            authPublicPathsContainer.unregisterPaths();
891                    }
892    
893                    AuthVerifierConfigurationContainer authVerifierConfigurationContainer =
894                            _authVerifierConfigurationContainerMap.remove(servletContextName);
895    
896                    if (authVerifierConfigurationContainer != null) {
897                            authVerifierConfigurationContainer.unregisterConfigurations();
898                    }
899    
900                    AutoDeployListenersContainer autoDeployListenersContainer =
901                            _autoDeployListenersContainerMap.remove(servletContextName);
902    
903                    if (autoDeployListenersContainer != null) {
904                            autoDeployListenersContainer.unregisterAutoDeployListeners();
905                    }
906    
907                    AutoLoginsContainer autoLoginsContainer =
908                            _autoLoginsContainerMap.remove(servletContextName);
909    
910                    if (autoLoginsContainer != null) {
911                            autoLoginsContainer.unregisterAutoLogins();
912                    }
913    
914                    CustomJspBag customJspBag = _customJspBagsMap.remove(
915                            servletContextName);
916    
917                    if (customJspBag != null) {
918                            destroyCustomJspBag(servletContextName, customJspBag);
919                    }
920    
921                    EventsContainer eventsContainer = _eventsContainerMap.remove(
922                            servletContextName);
923    
924                    if (eventsContainer != null) {
925                            eventsContainer.unregisterEvents();
926                    }
927    
928                    HotDeployListenersContainer hotDeployListenersContainer =
929                            _hotDeployListenersContainerMap.remove(servletContextName);
930    
931                    if (hotDeployListenersContainer != null) {
932                            hotDeployListenersContainer.unregisterHotDeployListeners();
933                    }
934    
935                    IndexerPostProcessorContainer indexerPostProcessorContainer =
936                            _indexerPostProcessorContainerMap.remove(servletContextName);
937    
938                    if (indexerPostProcessorContainer != null) {
939                            indexerPostProcessorContainer.unregisterIndexerPostProcessor();
940                    }
941    
942                    LanguagesContainer languagesContainer = _languagesContainerMap.remove(
943                            servletContextName);
944    
945                    if (languagesContainer != null) {
946                            languagesContainer.unregisterLanguages();
947                    }
948    
949                    ModelListenersContainer modelListenersContainer =
950                            _modelListenersContainerMap.remove(servletContextName);
951    
952                    if (modelListenersContainer != null) {
953                            modelListenersContainer.unregisterModelListeners(
954                                    servletContextName);
955                    }
956    
957                    Properties portalProperties = _portalPropertiesMap.remove(
958                            servletContextName);
959    
960                    if (portalProperties != null) {
961                            destroyPortalProperties(servletContextName, portalProperties);
962                    }
963    
964                    destroyServices(servletContextName);
965    
966                    ServletFiltersContainer servletFiltersContainer =
967                            _servletFiltersContainerMap.remove(servletContextName);
968    
969                    if (servletFiltersContainer != null) {
970                            servletFiltersContainer.unregisterFilterMappings();
971                    }
972    
973                    StrutsActionsContainer strutsActionContainer =
974                            _strutsActionsContainerMap.remove(servletContextName);
975    
976                    if (strutsActionContainer != null) {
977                            strutsActionContainer.unregisterStrutsActions();
978                    }
979    
980                    unregisterClpMessageListeners(servletContext);
981    
982                    if (_log.isInfoEnabled()) {
983                            _log.info("Hook for " + servletContextName + " was unregistered");
984                    }
985            }
986    
987            protected void getCustomJsps(
988                    ServletContext servletContext, String webDir, String resourcePath,
989                    List<String> customJsps) {
990    
991                    Set<String> resourcePaths = servletContext.getResourcePaths(
992                            resourcePath);
993    
994                    if ((resourcePaths == null) || resourcePaths.isEmpty()) {
995                            return;
996                    }
997    
998                    for (String curResourcePath : resourcePaths) {
999                            if (curResourcePath.endsWith(StringPool.SLASH)) {
1000                                    getCustomJsps(
1001                                            servletContext, webDir, curResourcePath, customJsps);
1002                            }
1003                            else {
1004                                    String customJsp = webDir + curResourcePath;
1005    
1006                                    customJsp = StringUtil.replace(
1007                                            customJsp, StringPool.DOUBLE_SLASH, StringPool.SLASH);
1008    
1009                                    customJsps.add(customJsp);
1010                            }
1011                    }
1012            }
1013    
1014            protected Locale getLocale(String languagePropertiesLocation) {
1015                    int x = languagePropertiesLocation.indexOf(CharPool.UNDERLINE);
1016                    int y = languagePropertiesLocation.indexOf(".properties");
1017    
1018                    if ((x == -1) && (y != -1)) {
1019                            return new Locale(StringPool.BLANK);
1020                    }
1021    
1022                    Locale locale = null;
1023    
1024                    if ((x != -1) && (y != 1)) {
1025                            String localeKey = languagePropertiesLocation.substring(x + 1, y);
1026    
1027                            locale = LocaleUtil.fromLanguageId(localeKey, true, false);
1028                    }
1029    
1030                    return locale;
1031            }
1032    
1033            protected BasePersistence<?> getPersistence(
1034                    String servletContextName, String modelName) {
1035    
1036                    int pos = modelName.lastIndexOf(CharPool.PERIOD);
1037    
1038                    String entityName = modelName.substring(pos + 1);
1039    
1040                    pos = modelName.lastIndexOf(".model.");
1041    
1042                    String packagePath = modelName.substring(0, pos);
1043    
1044                    String beanName =
1045                            packagePath + ".service.persistence." + entityName + "Persistence";
1046    
1047                    try {
1048                            return (BasePersistence<?>)PortalBeanLocatorUtil.locate(beanName);
1049                    }
1050                    catch (BeanLocatorException ble) {
1051                            return (BasePersistence<?>)PortletBeanLocatorUtil.locate(
1052                                    servletContextName, beanName);
1053                    }
1054            }
1055    
1056            protected String getPortalJsp(String customJsp, String customJspDir) {
1057                    if (Validator.isNull(customJsp) || Validator.isNull(customJspDir)) {
1058                            return null;
1059                    }
1060    
1061                    int pos = customJsp.indexOf(customJspDir);
1062    
1063                    return customJsp.substring(pos + customJspDir.length());
1064            }
1065    
1066            protected File getPortalJspBackupFile(File portalJspFile) {
1067                    String fileName = portalJspFile.getName();
1068                    String filePath = portalJspFile.toString();
1069    
1070                    int fileNameIndex = fileName.lastIndexOf(CharPool.PERIOD);
1071    
1072                    if (fileNameIndex > 0) {
1073                            int filePathIndex = filePath.lastIndexOf(fileName);
1074    
1075                            fileName =
1076                                    fileName.substring(0, fileNameIndex) + ".portal" +
1077                                            fileName.substring(fileNameIndex);
1078    
1079                            filePath = filePath.substring(0, filePathIndex) + fileName;
1080                    }
1081                    else {
1082                            filePath += ".portal";
1083                    }
1084    
1085                    return new File(filePath);
1086            }
1087    
1088            protected void initAuthenticators(
1089                            ClassLoader portletClassLoader, Properties portalProperties,
1090                            String key, AuthenticatorsContainer authenticatorsContainer)
1091                    throws Exception {
1092    
1093                    String[] authenticatorClassNames = StringUtil.split(
1094                            portalProperties.getProperty(key));
1095    
1096                    for (String authenticatorClassName : authenticatorClassNames) {
1097                            Authenticator authenticator = (Authenticator)newInstance(
1098                                    portletClassLoader, Authenticator.class,
1099                                    authenticatorClassName);
1100    
1101                            authenticatorsContainer.registerAuthenticator(key, authenticator);
1102                    }
1103            }
1104    
1105            protected void initAuthenticators(
1106                            String servletContextName, ClassLoader portletClassLoader,
1107                            Properties portalProperties)
1108                    throws Exception {
1109    
1110                    AuthenticatorsContainer authenticatorsContainer =
1111                            new AuthenticatorsContainer();
1112    
1113                    _authenticatorsContainerMap.put(
1114                            servletContextName, authenticatorsContainer);
1115    
1116                    initAuthenticators(
1117                            portletClassLoader, portalProperties, AUTH_PIPELINE_PRE,
1118                            authenticatorsContainer);
1119                    initAuthenticators(
1120                            portletClassLoader, portalProperties, AUTH_PIPELINE_POST,
1121                            authenticatorsContainer);
1122            }
1123    
1124            protected void initAuthFailures(
1125                            ClassLoader portletClassLoader, Properties portalProperties,
1126                            String key, AuthFailuresContainer authFailuresContainer)
1127                    throws Exception {
1128    
1129                    String[] authFailureClassNames = StringUtil.split(
1130                            portalProperties.getProperty(key));
1131    
1132                    for (String authFailureClassName : authFailureClassNames) {
1133                            AuthFailure authFailure = (AuthFailure)newInstance(
1134                                    portletClassLoader, AuthFailure.class, authFailureClassName);
1135    
1136                            authFailuresContainer.registerAuthFailure(key, authFailure);
1137                    }
1138            }
1139    
1140            protected void initAuthFailures(
1141                            String servletContextName, ClassLoader portletClassLoader,
1142                            Properties portalProperties)
1143                    throws Exception {
1144    
1145                    AuthFailuresContainer authFailuresContainer =
1146                            new AuthFailuresContainer();
1147    
1148                    _authFailuresContainerMap.put(
1149                            servletContextName, authFailuresContainer);
1150    
1151                    initAuthFailures(
1152                            portletClassLoader, portalProperties, AUTH_FAILURE,
1153                            authFailuresContainer);
1154                    initAuthFailures(
1155                            portletClassLoader, portalProperties, AUTH_MAX_FAILURES,
1156                            authFailuresContainer);
1157            }
1158    
1159            protected void initAuthPublicPaths(
1160                            String servletContextName, Properties portalProperties)
1161                    throws Exception {
1162    
1163                    AuthPublicPathsContainer authPublicPathsContainer =
1164                            new AuthPublicPathsContainer();
1165    
1166                    _authPublicPathsContainerMap.put(
1167                            servletContextName, authPublicPathsContainer);
1168    
1169                    String[] publicPaths = StringUtil.split(
1170                            portalProperties.getProperty(AUTH_PUBLIC_PATHS));
1171    
1172                    authPublicPathsContainer.registerPaths(publicPaths);
1173            }
1174    
1175            protected void initAuthVerifiers(
1176                            String servletContextName, ClassLoader portletClassLoader,
1177                            Properties portalProperties)
1178                    throws Exception {
1179    
1180                    AuthVerifierConfigurationContainer authVerifierConfigurationContainer =
1181                            new AuthVerifierConfigurationContainer();
1182    
1183                    _authVerifierConfigurationContainerMap.put(
1184                            servletContextName, authVerifierConfigurationContainer);
1185    
1186                    String[] authVerifierClassNames = StringUtil.split(
1187                            portalProperties.getProperty(AUTH_VERIFIER_PIPELINE));
1188    
1189                    for (String authVerifierClassName : authVerifierClassNames) {
1190                            AuthVerifierConfiguration authVerifierConfiguration =
1191                                    new AuthVerifierConfiguration();
1192    
1193                            AuthVerifier authVerifier = (AuthVerifier)newInstance(
1194                                    portletClassLoader, AuthVerifier.class, authVerifierClassName);
1195    
1196                            authVerifierConfiguration.setAuthVerifier(authVerifier);
1197    
1198                            authVerifierConfiguration.setAuthVerifierClassName(
1199                                    authVerifierClassName);
1200    
1201                            Properties properties = PropertiesUtil.getProperties(
1202                                    portalProperties,
1203                                    AuthVerifierPipeline.getAuthVerifierPropertyName(
1204                                            authVerifierClassName),
1205                                    true);
1206    
1207                            authVerifierConfiguration.setProperties(properties);
1208    
1209                            authVerifierConfigurationContainer.
1210                                    registerAuthVerifierConfiguration(authVerifierConfiguration);
1211                    }
1212            }
1213    
1214            protected void initAutoDeployListeners(
1215                            String servletContextName, ClassLoader portletClassLoader,
1216                            Properties portalProperties)
1217                    throws Exception {
1218    
1219                    String[] autoDeployListenerClassNames = StringUtil.split(
1220                            portalProperties.getProperty(PropsKeys.AUTO_DEPLOY_LISTENERS));
1221    
1222                    if (autoDeployListenerClassNames.length == 0) {
1223                            return;
1224                    }
1225    
1226                    AutoDeployListenersContainer autoDeployListenersContainer =
1227                            new AutoDeployListenersContainer();
1228    
1229                    _autoDeployListenersContainerMap.put(
1230                            servletContextName, autoDeployListenersContainer);
1231    
1232                    for (String autoDeployListenerClassName :
1233                                    autoDeployListenerClassNames) {
1234    
1235                            AutoDeployListener autoDeployListener =
1236                                    (AutoDeployListener)newInstance(
1237                                            portletClassLoader, AutoDeployListener.class,
1238                                            autoDeployListenerClassName);
1239    
1240                            autoDeployListenersContainer.registerAutoDeployListener(
1241                                    autoDeployListener);
1242                    }
1243            }
1244    
1245            protected void initAutoLogins(
1246                            String servletContextName, ClassLoader portletClassLoader,
1247                            Properties portalProperties)
1248                    throws Exception {
1249    
1250                    AutoLoginsContainer autoLoginsContainer = new AutoLoginsContainer();
1251    
1252                    _autoLoginsContainerMap.put(servletContextName, autoLoginsContainer);
1253    
1254                    String[] autoLoginClassNames = StringUtil.split(
1255                            portalProperties.getProperty(AUTO_LOGIN_HOOKS));
1256    
1257                    for (String autoLoginClassName : autoLoginClassNames) {
1258                            AutoLogin autoLogin = (AutoLogin)newInstance(
1259                                    portletClassLoader, AutoLogin.class, autoLoginClassName);
1260    
1261                            autoLoginsContainer.registerAutoLogin(autoLogin);
1262                    }
1263            }
1264    
1265            protected void initCustomJspBag(
1266                            String servletContextName, String displayName,
1267                            CustomJspBag customJspBag)
1268                    throws Exception {
1269    
1270                    String customJspDir = customJspBag.getCustomJspDir();
1271                    boolean customJspGlobal = customJspBag.isCustomJspGlobal();
1272                    List<String> customJsps = customJspBag.getCustomJsps();
1273    
1274                    String portalWebDir = PortalUtil.getPortalWebDir();
1275    
1276                    for (String customJsp : customJsps) {
1277                            String portalJsp = getPortalJsp(customJsp, customJspDir);
1278    
1279                            if (customJspGlobal) {
1280                                    File portalJspFile = new File(portalWebDir + portalJsp);
1281                                    File portalJspBackupFile = getPortalJspBackupFile(
1282                                            portalJspFile);
1283    
1284                                    if (portalJspFile.exists() && !portalJspBackupFile.exists()) {
1285                                            FileUtil.copyFile(portalJspFile, portalJspBackupFile);
1286                                    }
1287                            }
1288                            else {
1289                                    portalJsp = CustomJspRegistryUtil.getCustomJspFileName(
1290                                            servletContextName, portalJsp);
1291                            }
1292    
1293                            FileUtil.copyFile(customJsp, portalWebDir + portalJsp);
1294                    }
1295    
1296                    if (!customJspGlobal) {
1297                            CustomJspRegistryUtil.registerServletContextName(
1298                                    servletContextName, displayName);
1299                    }
1300            }
1301    
1302            protected void initCustomJspDir(
1303                            ServletContext servletContext, String servletContextName,
1304                            ClassLoader portletClassLoader, PluginPackage pluginPackage,
1305                            Element rootElement)
1306                    throws Exception {
1307    
1308                    String customJspDir = rootElement.elementText("custom-jsp-dir");
1309    
1310                    if (Validator.isNull(customJspDir)) {
1311                            return;
1312                    }
1313    
1314                    if (!checkPermission(
1315                                    PACLConstants.PORTAL_HOOK_PERMISSION_CUSTOM_JSP_DIR,
1316                                    portletClassLoader, null, "Rejecting custom JSP directory")) {
1317    
1318                            return;
1319                    }
1320    
1321                    if (_log.isDebugEnabled()) {
1322                            _log.debug("Custom JSP directory: " + customJspDir);
1323                    }
1324    
1325                    boolean customJspGlobal = GetterUtil.getBoolean(
1326                            rootElement.elementText("custom-jsp-global"), true);
1327    
1328                    List<String> customJsps = new ArrayList<String>();
1329    
1330                    String webDir = servletContext.getRealPath(StringPool.SLASH);
1331    
1332                    getCustomJsps(servletContext, webDir, customJspDir, customJsps);
1333    
1334                    if (customJsps.isEmpty()) {
1335                            return;
1336                    }
1337    
1338                    CustomJspBag customJspBag = new CustomJspBag(
1339                            customJspDir, customJspGlobal, customJsps);
1340    
1341                    if (_log.isDebugEnabled()) {
1342                            StringBundler sb = new StringBundler(customJsps.size() * 2);
1343    
1344                            sb.append("Custom JSP files:\n");
1345    
1346                            for (int i = 0; i < customJsps.size(); i++) {
1347                                    String customJsp = customJsps.get(i);
1348    
1349                                    sb.append(customJsp);
1350    
1351                                    if ((i + 1) < customJsps.size()) {
1352                                            sb.append(StringPool.NEW_LINE);
1353                                    }
1354                            }
1355    
1356                            Log log = SanitizerLogWrapper.allowCRLF(_log);
1357    
1358                            log.debug(sb.toString());
1359                    }
1360    
1361                    if (PropsValues.HOT_DEPLOY_HOOK_CUSTOM_JSP_VERIFICATION_ENABLED &&
1362                            customJspGlobal && !_customJspBagsMap.isEmpty() &&
1363                            !_customJspBagsMap.containsKey(servletContextName)) {
1364    
1365                            verifyCustomJsps(servletContextName, customJspBag);
1366                    }
1367    
1368                    _customJspBagsMap.put(servletContextName, customJspBag);
1369    
1370                    initCustomJspBag(
1371                            servletContextName, pluginPackage.getName(), customJspBag);
1372            }
1373    
1374            protected Object initEvent(
1375                            String eventName, String eventClassName,
1376                            ClassLoader portletClassLoader)
1377                    throws Exception {
1378    
1379                    if (eventName.equals(APPLICATION_STARTUP_EVENTS)) {
1380                            Class<?> clazz = portletClassLoader.loadClass(eventClassName);
1381    
1382                            SimpleAction simpleAction = (SimpleAction)clazz.newInstance();
1383    
1384                            simpleAction = new InvokerSimpleAction(
1385                                    simpleAction, portletClassLoader);
1386    
1387                            Long companyId = CompanyThreadLocal.getCompanyId();
1388    
1389                            try {
1390                                    long[] companyIds = PortalInstances.getCompanyIds();
1391    
1392                                    for (long curCompanyId : companyIds) {
1393                                            CompanyThreadLocal.setCompanyId(curCompanyId);
1394    
1395                                            simpleAction.run(
1396                                                    new String[] {String.valueOf(curCompanyId)});
1397                                    }
1398                            }
1399                            finally {
1400                                    CompanyThreadLocal.setCompanyId(companyId);
1401                            }
1402    
1403                            return null;
1404                    }
1405    
1406                    if (_propsKeysEvents.contains(eventName)) {
1407                            Class<?> clazz = portletClassLoader.loadClass(eventClassName);
1408    
1409                            Action action = (Action)clazz.newInstance();
1410    
1411                            action = new InvokerAction(action, portletClassLoader);
1412    
1413                            EventsProcessorUtil.registerEvent(eventName, action);
1414    
1415                            return action;
1416                    }
1417    
1418                    if (_propsKeysSessionEvents.contains(eventName)) {
1419                            Class<?> clazz = portletClassLoader.loadClass(eventClassName);
1420    
1421                            SessionAction sessionAction = (SessionAction)clazz.newInstance();
1422    
1423                            sessionAction = new InvokerSessionAction(
1424                                    sessionAction, portletClassLoader);
1425    
1426                            EventsProcessorUtil.registerEvent(eventName, sessionAction);
1427    
1428                            return sessionAction;
1429                    }
1430    
1431                    return null;
1432            }
1433    
1434            protected void initEvents(
1435                            String servletContextName, ClassLoader portletClassLoader,
1436                            Properties portalProperties)
1437                    throws Exception {
1438    
1439                    EventsContainer eventsContainer = new EventsContainer();
1440    
1441                    _eventsContainerMap.put(servletContextName, eventsContainer);
1442    
1443                    for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
1444                            String key = (String)entry.getKey();
1445    
1446                            if (!key.equals(APPLICATION_STARTUP_EVENTS) &&
1447                                    !_propsKeysEvents.contains(key) &&
1448                                    !_propsKeysSessionEvents.contains(key)) {
1449    
1450                                    continue;
1451                            }
1452    
1453                            String eventName = key;
1454                            String[] eventClassNames = StringUtil.split(
1455                                    (String)entry.getValue());
1456    
1457                            for (String eventClassName : eventClassNames) {
1458                                    Object obj = initEvent(
1459                                            eventName, eventClassName, portletClassLoader);
1460    
1461                                    if (obj == null) {
1462                                            continue;
1463                                    }
1464    
1465                                    eventsContainer.registerEvent(eventName, obj);
1466                            }
1467                    }
1468            }
1469    
1470            protected void initHotDeployListeners(
1471                            String servletContextName, ClassLoader portletClassLoader,
1472                            Properties portalProperties)
1473                    throws Exception {
1474    
1475                    String[] hotDeployListenerClassNames = StringUtil.split(
1476                            portalProperties.getProperty(PropsKeys.HOT_DEPLOY_LISTENERS));
1477    
1478                    if (hotDeployListenerClassNames.length == 0) {
1479                            return;
1480                    }
1481    
1482                    HotDeployListenersContainer hotDeployListenersContainer =
1483                            new HotDeployListenersContainer();
1484    
1485                    _hotDeployListenersContainerMap.put(
1486                            servletContextName, hotDeployListenersContainer);
1487    
1488                    for (String hotDeployListenerClassName : hotDeployListenerClassNames) {
1489                            HotDeployListener hotDeployListener =
1490                                    (HotDeployListener)newInstance(
1491                                            portletClassLoader, HotDeployListener.class,
1492                                            hotDeployListenerClassName);
1493    
1494                            hotDeployListenersContainer.registerHotDeployListener(
1495                                    hotDeployListener);
1496                    }
1497            }
1498    
1499            protected void initIndexerPostProcessors(
1500                            String servletContextName, ClassLoader portletClassLoader,
1501                            Element parentElement)
1502                    throws Exception {
1503    
1504                    IndexerPostProcessorContainer indexerPostProcessorContainer =
1505                            _indexerPostProcessorContainerMap.get(servletContextName);
1506    
1507                    if (indexerPostProcessorContainer == null) {
1508                            indexerPostProcessorContainer = new IndexerPostProcessorContainer();
1509    
1510                            _indexerPostProcessorContainerMap.put(
1511                                    servletContextName, indexerPostProcessorContainer);
1512                    }
1513    
1514                    List<Element> indexerPostProcessorElements = parentElement.elements(
1515                            "indexer-post-processor");
1516    
1517                    for (Element indexerPostProcessorElement :
1518                                    indexerPostProcessorElements) {
1519    
1520                            String indexerClassName = indexerPostProcessorElement.elementText(
1521                                    "indexer-class-name");
1522    
1523                            if (!checkPermission(
1524                                            PACLConstants.PORTAL_HOOK_PERMISSION_INDEXER,
1525                                            portletClassLoader, indexerClassName,
1526                                            "Rejecting indexer " + indexerClassName)) {
1527    
1528                                    continue;
1529                            }
1530    
1531                            String indexerPostProcessorImpl =
1532                                    indexerPostProcessorElement.elementText(
1533                                            "indexer-post-processor-impl");
1534    
1535                            Indexer indexer = IndexerRegistryUtil.getIndexer(indexerClassName);
1536    
1537                            if (indexer == null) {
1538                                    _log.error("No indexer for " + indexerClassName + " was found");
1539    
1540                                    continue;
1541                            }
1542    
1543                            IndexerPostProcessor indexerPostProcessor =
1544                                    (IndexerPostProcessor)InstanceFactory.newInstance(
1545                                            portletClassLoader, indexerPostProcessorImpl);
1546    
1547                            indexer.registerIndexerPostProcessor(indexerPostProcessor);
1548    
1549                            indexerPostProcessorContainer.registerIndexerPostProcessor(
1550                                    indexerClassName, indexerPostProcessor);
1551                    }
1552            }
1553    
1554            protected void initLanguageProperties(
1555                            String servletContextName, ClassLoader portletClassLoader,
1556                            Element parentElement)
1557                    throws Exception {
1558    
1559                    LanguagesContainer languagesContainer = new LanguagesContainer();
1560    
1561                    _languagesContainerMap.put(servletContextName, languagesContainer);
1562    
1563                    List<Element> languagePropertiesElements = parentElement.elements(
1564                            "language-properties");
1565    
1566                    Map<String, String> baseLanguageMap = null;
1567                    Map<String, String> rootLanguageMap = null;
1568                    Locale rootLocale = null;
1569    
1570                    for (Element languagePropertiesElement : languagePropertiesElements) {
1571                            Properties properties = null;
1572    
1573                            String languagePropertiesLocation =
1574                                    languagePropertiesElement.getText();
1575    
1576                            Locale locale = getLocale(languagePropertiesLocation);
1577    
1578                            if (locale == null) {
1579                                    if (_log.isInfoEnabled()) {
1580                                            _log.info("Ignoring " + languagePropertiesLocation);
1581                                    }
1582    
1583                                    continue;
1584                            }
1585    
1586                            String languageId = LocaleUtil.toLanguageId(locale);
1587    
1588                            if (!StringPool.BLANK.equals(languageId) &&
1589                                    !checkPermission(
1590                                            PACLConstants.
1591                                                    PORTAL_HOOK_PERMISSION_LANGUAGE_PROPERTIES_LOCALE,
1592                                            portletClassLoader, locale, "Rejecting locale " + locale)) {
1593    
1594                                    continue;
1595                            }
1596    
1597                            try {
1598                                    URL url = portletClassLoader.getResource(
1599                                            languagePropertiesLocation);
1600    
1601                                    if (url == null) {
1602                                            continue;
1603                                    }
1604    
1605                                    InputStream is = url.openStream();
1606    
1607                                    properties = PropertiesUtil.load(is, StringPool.UTF8);
1608    
1609                                    is.close();
1610                            }
1611                            catch (Exception e) {
1612                                    _log.error("Unable to read " + languagePropertiesLocation, e);
1613    
1614                                    continue;
1615                            }
1616    
1617                            Map<String, String> languageMap = new HashMap<String, String>();
1618    
1619                            if (!StringPool.BLANK.equals(languageId) && (rootLocale != null) &&
1620                                    Validator.equals(
1621                                            locale.getLanguage(), rootLocale.getLanguage())) {
1622    
1623                                    languageMap.putAll(rootLanguageMap);
1624                            }
1625                            else if (baseLanguageMap != null) {
1626                                    languageMap.putAll(baseLanguageMap);
1627                            }
1628    
1629                            for (Map.Entry<Object, Object> entry : properties.entrySet()) {
1630                                    String key = (String)entry.getKey();
1631                                    String value = (String)entry.getValue();
1632    
1633                                    value = LanguageResources.fixValue(value);
1634    
1635                                    languageMap.put(key, value);
1636                            }
1637    
1638                            if (!StringPool.BLANK.equals(languageId)) {
1639                                    languagesContainer.addLanguage(locale, languageMap);
1640    
1641                                    if (Validator.isNull(locale.getCountry())) {
1642                                            rootLanguageMap = languageMap;
1643                                            rootLocale = locale;
1644                                    }
1645                            }
1646                            else if ((baseLanguageMap == null) && !languageMap.isEmpty()) {
1647                                    baseLanguageMap = languageMap;
1648                            }
1649                    }
1650    
1651                    if (baseLanguageMap != null) {
1652                            Locale locale = new Locale(StringPool.BLANK);
1653    
1654                            languagesContainer.addLanguage(locale, baseLanguageMap);
1655                    }
1656            }
1657    
1658            @SuppressWarnings("rawtypes")
1659            protected ModelListener<BaseModel<?>> initModelListener(
1660                            String servletContextName, ClassLoader portletClassLoader,
1661                            String modelName, String modelListenerClassName)
1662                    throws Exception {
1663    
1664                    ModelListener<BaseModel<?>> modelListener =
1665                            (ModelListener<BaseModel<?>>)newInstance(
1666                                    portletClassLoader, ModelListener.class,
1667                                    modelListenerClassName);
1668    
1669                    BasePersistence persistence = getPersistence(
1670                            servletContextName, modelName);
1671    
1672                    persistence.registerListener(modelListener);
1673    
1674                    return modelListener;
1675            }
1676    
1677            protected void initModelListeners(
1678                            String servletContextName, ClassLoader portletClassLoader,
1679                            Properties portalProperties)
1680                    throws Exception {
1681    
1682                    ModelListenersContainer modelListenersContainer =
1683                            new ModelListenersContainer();
1684    
1685                    _modelListenersContainerMap.put(
1686                            servletContextName, modelListenersContainer);
1687    
1688                    for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
1689                            String key = (String)entry.getKey();
1690    
1691                            if (!key.startsWith(VALUE_OBJECT_LISTENER)) {
1692                                    continue;
1693                            }
1694    
1695                            String modelName = key.substring(VALUE_OBJECT_LISTENER.length());
1696    
1697                            String[] modelListenerClassNames = StringUtil.split(
1698                                    (String)entry.getValue());
1699    
1700                            for (String modelListenerClassName : modelListenerClassNames) {
1701                                    ModelListener<BaseModel<?>> modelListener = initModelListener(
1702                                            servletContextName, portletClassLoader, modelName,
1703                                            modelListenerClassName);
1704    
1705                                    if (modelListener != null) {
1706                                            modelListenersContainer.registerModelListener(
1707                                                    modelName, modelListener);
1708                                    }
1709                            }
1710                    }
1711            }
1712    
1713            protected void initPortalProperties(
1714                            String servletContextName, ClassLoader portletClassLoader,
1715                            Element parentElement)
1716                    throws Exception {
1717    
1718                    String portalPropertiesLocation = parentElement.elementText(
1719                            "portal-properties");
1720    
1721                    if (Validator.isNull(portalPropertiesLocation)) {
1722                            return;
1723                    }
1724    
1725                    Configuration portalPropertiesConfiguration = null;
1726    
1727                    try {
1728                            String name = portalPropertiesLocation;
1729    
1730                            int pos = name.lastIndexOf(".properties");
1731    
1732                            if (pos != -1) {
1733                                    name = name.substring(0, pos);
1734                            }
1735    
1736                            portalPropertiesConfiguration =
1737                                    ConfigurationFactoryUtil.getConfiguration(
1738                                            portletClassLoader, name);
1739                    }
1740                    catch (Exception e) {
1741                            _log.error("Unable to read " + portalPropertiesLocation, e);
1742                    }
1743    
1744                    if (portalPropertiesConfiguration == null) {
1745                            return;
1746                    }
1747    
1748                    Properties portalProperties =
1749                            portalPropertiesConfiguration.getProperties();
1750    
1751                    if (portalProperties.isEmpty()) {
1752                            return;
1753                    }
1754    
1755                    Set<Object> set = portalProperties.keySet();
1756    
1757                    Iterator<Object> iterator = set.iterator();
1758    
1759                    while (iterator.hasNext()) {
1760                            String key = (String)iterator.next();
1761    
1762                            if (!checkPermission(
1763                                            PACLConstants.PORTAL_HOOK_PERMISSION_PORTAL_PROPERTIES_KEY,
1764                                            portletClassLoader, key,
1765                                            "Rejecting portal.properties key " + key)) {
1766    
1767                                    iterator.remove();
1768                            }
1769                    }
1770    
1771                    Properties unfilteredPortalProperties =
1772                            (Properties)portalProperties.clone();
1773    
1774                    portalProperties.remove(PropsKeys.RELEASE_INFO_BUILD_NUMBER);
1775                    portalProperties.remove(PropsKeys.RELEASE_INFO_PREVIOUS_BUILD_NUMBER);
1776                    portalProperties.remove(PropsKeys.UPGRADE_PROCESSES);
1777    
1778                    _portalPropertiesMap.put(servletContextName, portalProperties);
1779    
1780                    // Initialize properties, auto logins, model listeners, and events in
1781                    // that specific order. Events have to be loaded last because they may
1782                    // require model listeners to have been registered.
1783    
1784                    initPortalProperties(
1785                            servletContextName, portletClassLoader, portalProperties,
1786                            unfilteredPortalProperties);
1787                    initAuthFailures(
1788                            servletContextName, portletClassLoader, portalProperties);
1789                    initAutoDeployListeners(
1790                            servletContextName, portletClassLoader, portalProperties);
1791                    initAutoLogins(
1792                            servletContextName, portletClassLoader, portalProperties);
1793                    initAuthenticators(
1794                            servletContextName, portletClassLoader, portalProperties);
1795                    initAuthVerifiers(
1796                            servletContextName, portletClassLoader, portalProperties);
1797                    initHotDeployListeners(
1798                            servletContextName, portletClassLoader, portalProperties);
1799                    initModelListeners(
1800                            servletContextName, portletClassLoader, portalProperties);
1801                    initEvents(servletContextName, portletClassLoader, portalProperties);
1802            }
1803    
1804            protected void initPortalProperties(
1805                            String servletContextName, ClassLoader portletClassLoader,
1806                            Properties portalProperties, Properties unfilteredPortalProperties)
1807                    throws Exception {
1808    
1809                    PropsUtil.addProperties(portalProperties);
1810    
1811                    if (_log.isDebugEnabled() && portalProperties.containsKey(LOCALES)) {
1812                            _log.debug(
1813                                    "Portlet locales " + portalProperties.getProperty(LOCALES));
1814                            _log.debug("Merged locales " + PropsUtil.get(LOCALES));
1815                            _log.debug(
1816                                    "Merged locales array length " +
1817                                            PropsUtil.getArray(LOCALES).length);
1818                    }
1819    
1820                    for (String key : _PROPS_VALUES_OBSOLETE) {
1821                            if (_log.isInfoEnabled() && portalProperties.contains(key)) {
1822                                    _log.info("Portal property \"" + key + "\" is obsolete");
1823                            }
1824                    }
1825    
1826                    resetPortalProperties(servletContextName, portalProperties, true);
1827    
1828                    if (portalProperties.containsKey(
1829                                    PropsKeys.ASSET_PUBLISHER_ASSET_ENTRY_QUERY_PROCESSORS)) {
1830    
1831                            String[] assetQueryProcessorClassNames = StringUtil.split(
1832                                    portalProperties.getProperty(
1833                                            PropsKeys.ASSET_PUBLISHER_ASSET_ENTRY_QUERY_PROCESSORS));
1834    
1835                            for (String assetQueryProcessorClassName :
1836                                            assetQueryProcessorClassNames) {
1837    
1838                                    AssetEntryQueryProcessor assetQueryProcessor =
1839                                            (AssetEntryQueryProcessor)newInstance(
1840                                                    portletClassLoader, AssetEntryQueryProcessor.class,
1841                                                    assetQueryProcessorClassName);
1842    
1843                                    AssetPublisherUtil.registerAssetQueryProcessor(
1844                                            assetQueryProcessorClassName, assetQueryProcessor);
1845    
1846                                    if (_log.isDebugEnabled()) {
1847                                            _log.debug(
1848                                                    "Registered asset query processor " +
1849                                                            assetQueryProcessorClassName);
1850                                    }
1851                            }
1852                    }
1853    
1854                    if (portalProperties.containsKey(PropsKeys.AUTH_PUBLIC_PATHS)) {
1855                            initAuthPublicPaths(servletContextName, portalProperties);
1856                    }
1857    
1858                    if (portalProperties.containsKey(PropsKeys.AUTH_TOKEN_IMPL)) {
1859                            String authTokenClassName = portalProperties.getProperty(
1860                                    PropsKeys.AUTH_TOKEN_IMPL);
1861    
1862                            AuthToken authToken = (AuthToken)newInstance(
1863                                    portletClassLoader, AuthToken.class, authTokenClassName);
1864    
1865                            AuthTokenWrapper authTokenWrapper =
1866                                    (AuthTokenWrapper)AuthTokenUtil.getAuthToken();
1867    
1868                            authTokenWrapper.setAuthToken(authToken);
1869                    }
1870    
1871                    if (portalProperties.containsKey(PropsKeys.CAPTCHA_ENGINE_IMPL)) {
1872                            String captchaClassName = portalProperties.getProperty(
1873                                    PropsKeys.CAPTCHA_ENGINE_IMPL);
1874    
1875                            Captcha captcha = (Captcha)newInstance(
1876                                    portletClassLoader, Captcha.class, captchaClassName);
1877    
1878                            CaptchaImpl captchaImpl = null;
1879    
1880                            Captcha currentCaptcha = CaptchaUtil.getCaptcha();
1881    
1882                            if (currentCaptcha instanceof DoPrivilegedBean) {
1883                                    DoPrivilegedBean doPrivilegedBean =
1884                                            (DoPrivilegedBean)currentCaptcha;
1885    
1886                                    captchaImpl = (CaptchaImpl)doPrivilegedBean.getActualBean();
1887                            }
1888                            else {
1889                                    captchaImpl = (CaptchaImpl)currentCaptcha;
1890                            }
1891    
1892                            captchaImpl.setCaptcha(captcha);
1893                    }
1894    
1895                    if (portalProperties.containsKey(
1896                                    PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS)) {
1897    
1898                            String controlPanelEntryClassName = portalProperties.getProperty(
1899                                    PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS);
1900    
1901                            ControlPanelEntry controlPanelEntry =
1902                                    (ControlPanelEntry)newInstance(
1903                                            portletClassLoader, ControlPanelEntry.class,
1904                                            controlPanelEntryClassName);
1905    
1906                            DefaultControlPanelEntryFactory.setInstance(controlPanelEntry);
1907                    }
1908    
1909                    if (portalProperties.containsKey(PropsKeys.DL_FILE_ENTRY_PROCESSORS)) {
1910                            String[] dlProcessorClassNames = StringUtil.split(
1911                                    portalProperties.getProperty(
1912                                            PropsKeys.DL_FILE_ENTRY_PROCESSORS));
1913    
1914                            DLFileEntryProcessorContainer dlFileEntryProcessorContainer =
1915                                    new DLFileEntryProcessorContainer();
1916    
1917                            _dlFileEntryProcessorContainerMap.put(
1918                                    servletContextName, dlFileEntryProcessorContainer);
1919    
1920                            for (String dlProcessorClassName : dlProcessorClassNames) {
1921                                    DLProcessor dlProcessor =
1922                                            (DLProcessor)InstanceFactory.newInstance(
1923                                                    portletClassLoader, dlProcessorClassName);
1924    
1925                                    dlProcessor = (DLProcessor)newInstance(
1926                                            portletClassLoader,
1927                                            ReflectionUtil.getInterfaces(
1928                                                    dlProcessor, portletClassLoader),
1929                                            dlProcessorClassName);
1930    
1931                                    dlFileEntryProcessorContainer.registerDLProcessor(dlProcessor);
1932                            }
1933                    }
1934    
1935                    if (portalProperties.containsKey(PropsKeys.DL_REPOSITORY_IMPL)) {
1936                            String[] dlRepositoryClassNames = StringUtil.split(
1937                                    portalProperties.getProperty(PropsKeys.DL_REPOSITORY_IMPL));
1938    
1939                            DLRepositoryContainer dlRepositoryContainer =
1940                                    new DLRepositoryContainer();
1941    
1942                            _dlRepositoryContainerMap.put(
1943                                    servletContextName, dlRepositoryContainer);
1944    
1945                            for (String dlRepositoryClassName : dlRepositoryClassNames) {
1946                                    RepositoryFactory repositoryFactory = new RepositoryFactoryImpl(
1947                                            dlRepositoryClassName, portletClassLoader);
1948    
1949                                    dlRepositoryContainer.registerRepositoryFactory(
1950                                            dlRepositoryClassName, repositoryFactory);
1951                            }
1952                    }
1953    
1954                    if (portalProperties.containsKey(PropsKeys.DL_STORE_ANTIVIRUS_IMPL)) {
1955                            String antivirusScannerClassName = portalProperties.getProperty(
1956                                    PropsKeys.DL_STORE_ANTIVIRUS_IMPL);
1957    
1958                            AntivirusScanner antivirusScanner = (AntivirusScanner)newInstance(
1959                                    portletClassLoader, AntivirusScanner.class,
1960                                    antivirusScannerClassName);
1961    
1962                            AntivirusScannerWrapper antivirusScannerWrapper =
1963                                    (AntivirusScannerWrapper)
1964                                            AntivirusScannerUtil.getAntivirusScanner();
1965    
1966                            antivirusScannerWrapper.setAntivirusScanner(antivirusScanner);
1967                    }
1968    
1969                    if (portalProperties.containsKey(PropsKeys.DL_STORE_IMPL)) {
1970                            String storeClassName = portalProperties.getProperty(
1971                                    PropsKeys.DL_STORE_IMPL);
1972    
1973                            Store store = (Store)newInstance(
1974                                    portletClassLoader, Store.class, storeClassName);
1975    
1976                            StoreFactory.setInstance(store);
1977                    }
1978    
1979                    if (portalProperties.containsKey(
1980                                    PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL)) {
1981    
1982                            String attributesTransformerClassName =
1983                                    portalProperties.getProperty(
1984                                            PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL);
1985    
1986                            AttributesTransformer attributesTransformer =
1987                                    (AttributesTransformer)newInstance(
1988                                            portletClassLoader, AttributesTransformer.class,
1989                                            attributesTransformerClassName);
1990    
1991                            AttributesTransformerFactory.setInstance(attributesTransformer);
1992                    }
1993    
1994                    if (portalProperties.containsKey(LOCK_LISTENERS)) {
1995                            LockListenerContainer lockListenerContainer =
1996                                    _lockListenerContainerMap.get(servletContextName);
1997    
1998                            if (lockListenerContainer == null) {
1999                                    lockListenerContainer = new LockListenerContainer();
2000    
2001                                    _lockListenerContainerMap.put(
2002                                            servletContextName, lockListenerContainer);
2003                            }
2004    
2005                            String[] lockListenerClassNames = StringUtil.split(
2006                                    portalProperties.getProperty(LOCK_LISTENERS));
2007    
2008                            for (String lockListenerClassName : lockListenerClassNames) {
2009                                    LockListener lockListener = (LockListener)newInstance(
2010                                            portletClassLoader, LockListener.class,
2011                                            lockListenerClassName);
2012    
2013                                    lockListenerContainer.registerLockListener(lockListener);
2014                            }
2015                    }
2016    
2017                    if (portalProperties.containsKey(PropsKeys.MAIL_HOOK_IMPL)) {
2018                            String mailHookClassName = portalProperties.getProperty(
2019                                    PropsKeys.MAIL_HOOK_IMPL);
2020    
2021                            com.liferay.mail.util.Hook mailHook =
2022                                    (com.liferay.mail.util.Hook)newInstance(
2023                                            portletClassLoader, com.liferay.mail.util.Hook.class,
2024                                            mailHookClassName);
2025    
2026                            com.liferay.mail.util.HookFactory.setInstance(mailHook);
2027                    }
2028    
2029                    if (portalProperties.containsKey(
2030                                    PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS)) {
2031    
2032                            String organizationMembershipPolicyClassName =
2033                                    portalProperties.getProperty(
2034                                            PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS);
2035    
2036                            OrganizationMembershipPolicyFactoryImpl
2037                                    organizationMembershipPolicyFactoryImpl =
2038                                            (OrganizationMembershipPolicyFactoryImpl)
2039                                                    OrganizationMembershipPolicyFactoryUtil.
2040                                                            getOrganizationMembershipPolicyFactory();
2041    
2042                            OrganizationMembershipPolicy organizationMembershipPolicy =
2043                                    (OrganizationMembershipPolicy)newInstance(
2044                                            portletClassLoader, OrganizationMembershipPolicy.class,
2045                                            organizationMembershipPolicyClassName);
2046    
2047                            organizationMembershipPolicyFactoryImpl.
2048                                    setOrganizationMembershipPolicy(organizationMembershipPolicy);
2049    
2050                            if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
2051                                    organizationMembershipPolicy.verifyPolicy();
2052                            }
2053                    }
2054    
2055                    if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_ROLES)) {
2056                            String roleMembershipPolicyClassName = portalProperties.getProperty(
2057                                    PropsKeys.MEMBERSHIP_POLICY_ROLES);
2058    
2059                            RoleMembershipPolicyFactoryImpl roleMembershipPolicyFactoryImpl =
2060                                    (RoleMembershipPolicyFactoryImpl)
2061                                            RoleMembershipPolicyFactoryUtil.
2062                                                    getRoleMembershipPolicyFactory();
2063    
2064                            RoleMembershipPolicy roleMembershipPolicy =
2065                                    (RoleMembershipPolicy)newInstance(
2066                                            portletClassLoader, RoleMembershipPolicy.class,
2067                                            roleMembershipPolicyClassName);
2068    
2069                            roleMembershipPolicyFactoryImpl.setRoleMembershipPolicy(
2070                                    roleMembershipPolicy);
2071    
2072                            if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
2073                                    roleMembershipPolicy.verifyPolicy();
2074                            }
2075                    }
2076    
2077                    if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_SITES)) {
2078                            String siteMembershipPolicyClassName = portalProperties.getProperty(
2079                                    PropsKeys.MEMBERSHIP_POLICY_SITES);
2080    
2081                            SiteMembershipPolicyFactoryImpl siteMembershipPolicyFactoryImpl =
2082                                    (SiteMembershipPolicyFactoryImpl)
2083                                            SiteMembershipPolicyFactoryUtil.
2084                                                    getSiteMembershipPolicyFactory();
2085    
2086                            SiteMembershipPolicy siteMembershipPolicy =
2087                                    (SiteMembershipPolicy)newInstance(
2088                                            portletClassLoader, SiteMembershipPolicy.class,
2089                                            siteMembershipPolicyClassName);
2090    
2091                            siteMembershipPolicyFactoryImpl.setSiteMembershipPolicy(
2092                                    siteMembershipPolicy);
2093    
2094                            if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
2095                                    siteMembershipPolicy.verifyPolicy();
2096                            }
2097                    }
2098    
2099                    if (portalProperties.containsKey(
2100                                    PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS)) {
2101    
2102                            String userGroupMembershipPolicyClassName =
2103                                    portalProperties.getProperty(
2104                                            PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS);
2105    
2106                            UserGroupMembershipPolicyFactoryImpl
2107                                    userGroupMembershipPolicyFactoryImpl =
2108                                            (UserGroupMembershipPolicyFactoryImpl)
2109                                                    UserGroupMembershipPolicyFactoryUtil.
2110                                                            getUserGroupMembershipPolicyFactory();
2111    
2112                            UserGroupMembershipPolicy userGroupMembershipPolicy =
2113                                    (UserGroupMembershipPolicy)newInstance(
2114                                            portletClassLoader, UserGroupMembershipPolicy.class,
2115                                            userGroupMembershipPolicyClassName);
2116    
2117                            userGroupMembershipPolicyFactoryImpl.setUserGroupMembershipPolicy(
2118                                    userGroupMembershipPolicy);
2119    
2120                            if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
2121                                    userGroupMembershipPolicy.verifyPolicy();
2122                            }
2123                    }
2124    
2125                    if (portalProperties.containsKey(PropsKeys.PASSWORDS_TOOLKIT)) {
2126                            String toolkitClassName = portalProperties.getProperty(
2127                                    PropsKeys.PASSWORDS_TOOLKIT);
2128    
2129                            Toolkit toolkit = (Toolkit)newInstance(
2130                                    portletClassLoader, Toolkit.class, toolkitClassName);
2131    
2132                            ToolkitWrapper toolkitWrapper =
2133                                    (ToolkitWrapper)PwdToolkitUtil.getToolkit();
2134    
2135                            toolkitWrapper.setToolkit(toolkit);
2136                    }
2137    
2138                    if (portalProperties.containsKey(PropsKeys.PHONE_NUMBER_FORMAT_IMPL)) {
2139                            String phoneNumberFormatClassName = portalProperties.getProperty(
2140                                    PropsKeys.PHONE_NUMBER_FORMAT_IMPL);
2141    
2142                            PhoneNumberFormat phoneNumberFormat =
2143                                    (PhoneNumberFormat)newInstance(
2144                                            portletClassLoader, PhoneNumberFormat.class,
2145                                            phoneNumberFormatClassName);
2146    
2147                            PhoneNumberFormatWrapper phoneNumberFormatWrapper =
2148                                    (PhoneNumberFormatWrapper)
2149                                            PhoneNumberFormatUtil.getPhoneNumberFormat();
2150    
2151                            phoneNumberFormatWrapper.setPhoneNumberFormat(phoneNumberFormat);
2152                    }
2153    
2154                    if (portalProperties.containsKey(PropsKeys.SANITIZER_IMPL)) {
2155                            String[] sanitizerClassNames = StringUtil.split(
2156                                    portalProperties.getProperty(PropsKeys.SANITIZER_IMPL));
2157    
2158                            SanitizerContainer sanitizerContainer = new SanitizerContainer();
2159    
2160                            _sanitizerContainerMap.put(servletContextName, sanitizerContainer);
2161    
2162                            for (String sanitizerClassName : sanitizerClassNames) {
2163                                    Sanitizer sanitizer = (Sanitizer)newInstance(
2164                                            portletClassLoader, Sanitizer.class, sanitizerClassName);
2165    
2166                                    sanitizerContainer.registerSanitizer(sanitizer);
2167                            }
2168                    }
2169    
2170                    if (portalProperties.containsKey(
2171                                    PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR)) {
2172    
2173                            String emailAddressGeneratorClassName =
2174                                    portalProperties.getProperty(
2175                                            PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR);
2176    
2177                            EmailAddressGenerator emailAddressGenerator =
2178                                    (EmailAddressGenerator)newInstance(
2179                                            portletClassLoader, EmailAddressGenerator.class,
2180                                            emailAddressGeneratorClassName);
2181    
2182                            EmailAddressGeneratorFactory.setInstance(emailAddressGenerator);
2183                    }
2184    
2185                    if (portalProperties.containsKey(
2186                                    PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR)) {
2187    
2188                            String emailAddressValidatorClassName =
2189                                    portalProperties.getProperty(
2190                                            PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR);
2191    
2192                            EmailAddressValidator emailAddressValidator =
2193                                    (EmailAddressValidator)newInstance(
2194                                            portletClassLoader, EmailAddressValidator.class,
2195                                            emailAddressValidatorClassName);
2196    
2197                            EmailAddressValidatorFactory.setInstance(emailAddressValidator);
2198                    }
2199    
2200                    if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_GENERATOR)) {
2201                            String fullNameGeneratorClassName = portalProperties.getProperty(
2202                                    PropsKeys.USERS_FULL_NAME_GENERATOR);
2203    
2204                            FullNameGenerator fullNameGenerator =
2205                                    (FullNameGenerator)newInstance(
2206                                            portletClassLoader, FullNameGenerator.class,
2207                                            fullNameGeneratorClassName);
2208    
2209                            FullNameGeneratorFactory.setInstance(fullNameGenerator);
2210                    }
2211    
2212                    if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_VALIDATOR)) {
2213                            String fullNameValidatorClassName = portalProperties.getProperty(
2214                                    PropsKeys.USERS_FULL_NAME_VALIDATOR);
2215    
2216                            FullNameValidator fullNameValidator =
2217                                    (FullNameValidator)newInstance(
2218                                            portletClassLoader, FullNameValidator.class,
2219                                            fullNameValidatorClassName);
2220    
2221                            FullNameValidatorFactory.setInstance(fullNameValidator);
2222                    }
2223    
2224                    if (portalProperties.containsKey(
2225                                    PropsKeys.USERS_SCREEN_NAME_GENERATOR)) {
2226    
2227                            String screenNameGeneratorClassName = portalProperties.getProperty(
2228                                    PropsKeys.USERS_SCREEN_NAME_GENERATOR);
2229    
2230                            ScreenNameGenerator screenNameGenerator =
2231                                    (ScreenNameGenerator)newInstance(
2232                                            portletClassLoader, ScreenNameGenerator.class,
2233                                            screenNameGeneratorClassName);
2234    
2235                            ScreenNameGeneratorFactory.setInstance(screenNameGenerator);
2236                    }
2237    
2238                    if (portalProperties.containsKey(
2239                                    PropsKeys.USERS_SCREEN_NAME_VALIDATOR)) {
2240    
2241                            String screenNameValidatorClassName = portalProperties.getProperty(
2242                                    PropsKeys.USERS_SCREEN_NAME_VALIDATOR);
2243    
2244                            ScreenNameValidator screenNameValidator =
2245                                    (ScreenNameValidator)newInstance(
2246                                            portletClassLoader, ScreenNameValidator.class,
2247                                            screenNameValidatorClassName);
2248    
2249                            ScreenNameValidatorFactory.setInstance(screenNameValidator);
2250                    }
2251    
2252                    Set<String> liferayFilterClassNames =
2253                            LiferayFilterTracker.getClassNames();
2254    
2255                    for (String liferayFilterClassName : liferayFilterClassNames) {
2256                            if (!portalProperties.containsKey(liferayFilterClassName)) {
2257                                    continue;
2258                            }
2259    
2260                            boolean filterEnabled = GetterUtil.getBoolean(
2261                                    portalProperties.getProperty(liferayFilterClassName));
2262    
2263                            Set<LiferayFilter> liferayFilters =
2264                                    LiferayFilterTracker.getLiferayFilters(liferayFilterClassName);
2265    
2266                            for (LiferayFilter liferayFilter : liferayFilters) {
2267                                    liferayFilter.setFilterEnabled(filterEnabled);
2268                            }
2269                    }
2270    
2271                    if (unfilteredPortalProperties.containsKey(
2272                                    PropsKeys.RELEASE_INFO_BUILD_NUMBER) ||
2273                            unfilteredPortalProperties.containsKey(
2274                                    PropsKeys.UPGRADE_PROCESSES)) {
2275    
2276                            updateRelease(
2277                                    servletContextName, portletClassLoader,
2278                                    unfilteredPortalProperties);
2279                    }
2280            }
2281    
2282            protected void initServices(
2283                            String servletContextName, ClassLoader portletClassLoader,
2284                            String serviceType, Class<?> serviceTypeClass,
2285                            Constructor<?> serviceImplConstructor, Object serviceProxy)
2286                    throws Exception {
2287    
2288                    AdvisedSupport advisedSupport = ServiceBeanAopProxy.getAdvisedSupport(
2289                            serviceProxy);
2290    
2291                    TargetSource targetSource = advisedSupport.getTargetSource();
2292    
2293                    Object previousService = targetSource.getTarget();
2294    
2295                    if (ProxyUtil.isProxyClass(previousService.getClass())) {
2296                            InvocationHandler invocationHandler =
2297                                    ProxyUtil.getInvocationHandler(previousService);
2298    
2299                            if (invocationHandler instanceof ClassLoaderBeanHandler) {
2300                                    ClassLoaderBeanHandler classLoaderBeanHandler =
2301                                            (ClassLoaderBeanHandler)invocationHandler;
2302    
2303                                    previousService = classLoaderBeanHandler.getBean();
2304                            }
2305                    }
2306    
2307                    if (!(previousService instanceof ServiceWrapper)) {
2308                            ClassLoader portalClassLoader =
2309                                    PortalClassLoaderUtil.getClassLoader();
2310    
2311                            previousService = ProxyUtil.newProxyInstance(
2312                                    portalClassLoader, new Class<?>[] {serviceTypeClass},
2313                                    new ClassLoaderBeanHandler(previousService, portalClassLoader));
2314                    }
2315    
2316                    Object nextService = serviceImplConstructor.newInstance(
2317                            previousService);
2318    
2319                    Object nextTarget = ProxyUtil.newProxyInstance(
2320                            portletClassLoader, new Class<?>[] {serviceTypeClass},
2321                            new ClassLoaderBeanHandler(nextService, portletClassLoader));
2322    
2323                    TargetSource nextTargetSource = new SingletonTargetSource(nextTarget);
2324    
2325                    advisedSupport.setTargetSource(nextTargetSource);
2326    
2327                    _servicesContainer.addServiceBag(
2328                            servletContextName, portletClassLoader, serviceType,
2329                            serviceTypeClass, serviceImplConstructor, previousService);
2330    
2331                    ServiceBeanAopCacheManagerUtil.reset();
2332            }
2333    
2334            protected Filter initServletFilter(
2335                            String filterClassName, ClassLoader portletClassLoader)
2336                    throws Exception {
2337    
2338                    Filter filter = (Filter)InstanceFactory.newInstance(
2339                            portletClassLoader, filterClassName);
2340    
2341                    List<Class<?>> interfaces = new ArrayList<Class<?>>();
2342    
2343                    if (filter instanceof TryFilter) {
2344                            interfaces.add(TryFilter.class);
2345                    }
2346    
2347                    if (filter instanceof TryFinallyFilter) {
2348                            interfaces.add(TryFinallyFilter.class);
2349                    }
2350    
2351                    if (filter instanceof WrapHttpServletRequestFilter) {
2352                            interfaces.add(WrapHttpServletRequestFilter.class);
2353                    }
2354    
2355                    if (filter instanceof WrapHttpServletResponseFilter) {
2356                            interfaces.add(WrapHttpServletResponseFilter.class);
2357                    }
2358    
2359                    if (filter instanceof LiferayFilter) {
2360                            interfaces.add(LiferayFilter.class);
2361                    }
2362                    else {
2363                            interfaces.add(Filter.class);
2364                    }
2365    
2366                    filter = (Filter)ProxyUtil.newProxyInstance(
2367                            portletClassLoader,
2368                            interfaces.toArray(new Class[interfaces.size()]),
2369                            new ClassLoaderBeanHandler(filter, portletClassLoader));
2370    
2371                    return filter;
2372            }
2373    
2374            protected void initServletFilters(
2375                            ServletContext servletContext, String servletContextName,
2376                            ClassLoader portletClassLoader, Element parentElement)
2377                    throws Exception {
2378    
2379                    ServletFiltersContainer servletFiltersContainer =
2380                            _servletFiltersContainerMap.get(servletContextName);
2381    
2382                    if (servletFiltersContainer == null) {
2383                            servletFiltersContainer = new ServletFiltersContainer();
2384    
2385                            _servletFiltersContainerMap.put(
2386                                    servletContextName, servletFiltersContainer);
2387                    }
2388    
2389                    List<Element> servletFilterElements = parentElement.elements(
2390                            "servlet-filter");
2391    
2392                    if (!servletFilterElements.isEmpty() &&
2393                            !checkPermission(
2394                                    PACLConstants.PORTAL_HOOK_PERMISSION_SERVLET_FILTERS,
2395                                    portletClassLoader, null, "Rejecting servlet filters")) {
2396    
2397                            return;
2398                    }
2399    
2400                    for (Element servletFilterElement : servletFilterElements) {
2401                            String servletFilterName = servletFilterElement.elementText(
2402                                    "servlet-filter-name");
2403                            String servletFilterImpl = servletFilterElement.elementText(
2404                                    "servlet-filter-impl");
2405    
2406                            List<Element> initParamElements = servletFilterElement.elements(
2407                                    "init-param");
2408    
2409                            Map<String, String> initParameterMap =
2410                                    new HashMap<String, String>();
2411    
2412                            for (Element initParamElement : initParamElements) {
2413                                    String paramName = initParamElement.elementText("param-name");
2414                                    String paramValue = initParamElement.elementText("param-value");
2415    
2416                                    initParameterMap.put(paramName, paramValue);
2417                            }
2418    
2419                            Filter filter = initServletFilter(
2420                                    servletFilterImpl, portletClassLoader);
2421    
2422                            FilterConfig filterConfig = new InvokerFilterConfig(
2423                                    servletContext, servletFilterName, initParameterMap);
2424    
2425                            filter.init(filterConfig);
2426    
2427                            servletFiltersContainer.registerFilter(
2428                                    servletFilterName, filter, filterConfig);
2429                    }
2430    
2431                    List<Element> servletFilterMappingElements = parentElement.elements(
2432                            "servlet-filter-mapping");
2433    
2434                    for (Element servletFilterMappingElement :
2435                                    servletFilterMappingElements) {
2436    
2437                            String servletFilterName = servletFilterMappingElement.elementText(
2438                                    "servlet-filter-name");
2439                            String afterFilter = servletFilterMappingElement.elementText(
2440                                    "after-filter");
2441                            String beforeFilter = servletFilterMappingElement.elementText(
2442                                    "before-filter");
2443    
2444                            String positionFilterName = beforeFilter;
2445                            boolean after = false;
2446    
2447                            if (Validator.isNotNull(afterFilter)) {
2448                                    positionFilterName = afterFilter;
2449                                    after = true;
2450                            }
2451    
2452                            List<Element> urlPatternElements =
2453                                    servletFilterMappingElement.elements("url-pattern");
2454    
2455                            List<String> urlPatterns = new ArrayList<String>();
2456    
2457                            for (Element urlPatternElement : urlPatternElements) {
2458                                    String urlPattern = urlPatternElement.getTextTrim();
2459    
2460                                    urlPatterns.add(urlPattern);
2461                            }
2462    
2463                            List<Element> dispatcherElements =
2464                                    servletFilterMappingElement.elements("dispatcher");
2465    
2466                            List<String> dispatchers = new ArrayList<String>();
2467    
2468                            for (Element dispatcherElement : dispatcherElements) {
2469                                    String dispatcher = dispatcherElement.getTextTrim();
2470    
2471                                    dispatcher = StringUtil.toUpperCase(dispatcher);
2472    
2473                                    dispatchers.add(dispatcher);
2474                            }
2475    
2476                            servletFiltersContainer.registerFilterMapping(
2477                                    servletFilterName, urlPatterns, dispatchers, positionFilterName,
2478                                    after);
2479                    }
2480            }
2481    
2482            protected Object initStrutsAction(
2483                            String strutsActionClassName, ClassLoader portletClassLoader)
2484                    throws Exception {
2485    
2486                    Object strutsAction = InstanceFactory.newInstance(
2487                            portletClassLoader, strutsActionClassName);
2488    
2489                    if (strutsAction instanceof StrutsAction) {
2490                            return ProxyUtil.newProxyInstance(
2491                                    portletClassLoader, new Class[] {StrutsAction.class},
2492                                    new ClassLoaderBeanHandler(strutsAction, portletClassLoader));
2493                    }
2494                    else {
2495                            return ProxyUtil.newProxyInstance(
2496                                    portletClassLoader, new Class[] {StrutsPortletAction.class},
2497                                    new ClassLoaderBeanHandler(strutsAction, portletClassLoader));
2498                    }
2499            }
2500    
2501            protected void initStrutsActions(
2502                            String servletContextName, ClassLoader portletClassLoader,
2503                            Element parentElement)
2504                    throws Exception {
2505    
2506                    StrutsActionsContainer strutsActionContainer =
2507                            _strutsActionsContainerMap.get(servletContextName);
2508    
2509                    if (strutsActionContainer == null) {
2510                            strutsActionContainer = new StrutsActionsContainer();
2511    
2512                            _strutsActionsContainerMap.put(
2513                                    servletContextName, strutsActionContainer);
2514                    }
2515    
2516                    List<Element> strutsActionElements = parentElement.elements(
2517                            "struts-action");
2518    
2519                    for (Element strutsActionElement : strutsActionElements) {
2520                            String strutsActionPath = strutsActionElement.elementText(
2521                                    "struts-action-path");
2522    
2523                            if (!checkPermission(
2524                                            PACLConstants.PORTAL_HOOK_PERMISSION_STRUTS_ACTION_PATH,
2525                                            portletClassLoader, strutsActionPath,
2526                                            "Rejecting struts action path " + strutsActionPath)) {
2527    
2528                                    continue;
2529                            }
2530    
2531                            String strutsActionImpl = strutsActionElement.elementText(
2532                                    "struts-action-impl");
2533    
2534                            Object strutsAction = initStrutsAction(
2535                                    strutsActionImpl, portletClassLoader);
2536    
2537                            strutsActionContainer.registerStrutsAction(
2538                                    strutsActionPath, strutsAction);
2539                    }
2540            }
2541    
2542            protected boolean isRTLHook(PluginPackage pluginPackage) {
2543                    String moduleGroupId = pluginPackage.getGroupId();
2544    
2545                    if (!moduleGroupId.equals(_RTL_HOOK_MODULE_GROUP_ID)) {
2546                            return false;
2547                    }
2548    
2549                    // LRDCOM-9735
2550    
2551                    List<String> tags = pluginPackage.getTags();
2552    
2553                    if (tags.contains(_RTL_HOOK_TAG)) {
2554                            return true;
2555                    }
2556    
2557                    // LPS-43009
2558    
2559                    String name = pluginPackage.getName();
2560    
2561                    if (name.startsWith(_RTL_HOOK_NAME)) {
2562                            return true;
2563                    }
2564    
2565                    return false;
2566            }
2567    
2568            protected void resetPortalProperties(
2569                            String servletContextName, Properties portalProperties,
2570                            boolean initPhase)
2571                    throws Exception {
2572    
2573                    for (String key : _PROPS_VALUES_BOOLEAN) {
2574                            String fieldName = StringUtil.replace(
2575                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2576                                    CharPool.UNDERLINE);
2577    
2578                            if (!containsKey(portalProperties, key)) {
2579                                    continue;
2580                            }
2581    
2582                            try {
2583                                    Field field = PropsValues.class.getField(fieldName);
2584    
2585                                    Boolean value = Boolean.valueOf(
2586                                            GetterUtil.getBoolean(PropsUtil.get(key)));
2587    
2588                                    field.setBoolean(null, value);
2589                            }
2590                            catch (Exception e) {
2591                                    _log.error(
2592                                            "Error setting field " + fieldName + ": " + e.getMessage());
2593                            }
2594                    }
2595    
2596                    for (String key : _PROPS_VALUES_INTEGER) {
2597                            String fieldName = StringUtil.replace(
2598                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2599                                    CharPool.UNDERLINE);
2600    
2601                            if (!containsKey(portalProperties, key)) {
2602                                    continue;
2603                            }
2604    
2605                            try {
2606                                    Field field = PropsValues.class.getField(fieldName);
2607    
2608                                    Integer value = Integer.valueOf(
2609                                            GetterUtil.getInteger(PropsUtil.get(key)));
2610    
2611                                    field.setInt(null, value);
2612                            }
2613                            catch (Exception e) {
2614                                    _log.error(
2615                                            "Error setting field " + fieldName + ": " + e.getMessage());
2616                            }
2617                    }
2618    
2619                    for (String key : _PROPS_VALUES_LONG) {
2620                            String fieldName = StringUtil.replace(
2621                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2622                                    CharPool.UNDERLINE);
2623    
2624                            if (!containsKey(portalProperties, key)) {
2625                                    continue;
2626                            }
2627    
2628                            try {
2629                                    Field field = PropsValues.class.getField(fieldName);
2630    
2631                                    Long value = Long.valueOf(
2632                                            GetterUtil.getLong(PropsUtil.get(key)));
2633    
2634                                    field.setLong(null, value);
2635                            }
2636                            catch (Exception e) {
2637                                    _log.error(
2638                                            "Error setting field " + fieldName + ": " + e.getMessage());
2639                            }
2640                    }
2641    
2642                    for (String key : _PROPS_VALUES_STRING) {
2643                            String fieldName = StringUtil.replace(
2644                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2645                                    CharPool.UNDERLINE);
2646    
2647                            if (!containsKey(portalProperties, key)) {
2648                                    continue;
2649                            }
2650    
2651                            try {
2652                                    Field field = PropsValues.class.getField(fieldName);
2653    
2654                                    String value = GetterUtil.getString(PropsUtil.get(key));
2655    
2656                                    field.set(null, value);
2657                            }
2658                            catch (Exception e) {
2659                                    _log.error(
2660                                            "Error setting field " + fieldName + ": " + e.getMessage());
2661                            }
2662                    }
2663    
2664                    resetPortalPropertiesStringArray(
2665                            servletContextName, portalProperties, initPhase,
2666                            _PROPS_VALUES_MERGE_STRING_ARRAY, _mergeStringArraysContainerMap);
2667    
2668                    resetPortalPropertiesStringArray(
2669                            servletContextName, portalProperties, initPhase,
2670                            _PROPS_VALUES_OVERRIDE_STRING_ARRAY,
2671                            _overrideStringArraysContainerMap);
2672    
2673                    if (containsKey(portalProperties, LOCALES) ||
2674                            containsKey(portalProperties, LOCALES_BETA)) {
2675    
2676                            PropsValues.LOCALES = PropsUtil.getArray(LOCALES);
2677    
2678                            LanguageUtil.init();
2679                    }
2680    
2681                    if (containsKey(portalProperties, LOCALES_ENABLED)) {
2682                            PropsValues.LOCALES_ENABLED = PropsUtil.getArray(LOCALES_ENABLED);
2683    
2684                            LanguageUtil.init();
2685                    }
2686    
2687                    if (containsKey(portalProperties, AUTH_TOKEN_IGNORE_ACTIONS)) {
2688                            AuthTokenWhitelistUtil.resetPortletCSRFWhitelistActions();
2689                    }
2690    
2691                    if (containsKey(portalProperties, AUTH_TOKEN_IGNORE_ORIGINS)) {
2692                            AuthTokenWhitelistUtil.resetOriginCSRFWhitelist();
2693                    }
2694    
2695                    if (containsKey(portalProperties, AUTH_TOKEN_IGNORE_PORTLETS)) {
2696                            AuthTokenWhitelistUtil.resetPortletCSRFWhitelist();
2697                    }
2698    
2699                    if (containsKey(
2700                                    portalProperties,
2701                                    PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST)) {
2702    
2703                            AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
2704                    }
2705    
2706                    if (containsKey(
2707                                    portalProperties,
2708                                    PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST_ACTIONS)) {
2709    
2710                            AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
2711                    }
2712    
2713                    if (containsKey(
2714                                    portalProperties, PORTLET_INTERRUPTED_REQUEST_WHITELIST)) {
2715    
2716                            InterruptedPortletRequestWhitelistUtil.
2717                                    resetPortletInvocationWhitelist();
2718                    }
2719    
2720                    if (containsKey(
2721                                    portalProperties,
2722                                    PORTLET_INTERRUPTED_REQUEST_WHITELIST_ACTIONS)) {
2723    
2724                            InterruptedPortletRequestWhitelistUtil.
2725                                    resetPortletInvocationWhitelistActions();
2726                    }
2727    
2728                    CacheUtil.clearCache();
2729    
2730                    JavaScriptBundleUtil.clearCache();
2731            }
2732    
2733            protected void resetPortalPropertiesStringArray(
2734                    String servletContextName, Properties portalProperties,
2735                    boolean initPhase, String[] propsValuesStringArray,
2736                    Map<String, StringArraysContainer> stringArraysContainerMap) {
2737    
2738                    for (String key : propsValuesStringArray) {
2739                            String fieldName = StringUtil.replace(
2740                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2741                                    CharPool.UNDERLINE);
2742    
2743                            if (!containsKey(portalProperties, key)) {
2744                                    continue;
2745                            }
2746    
2747                            try {
2748                                    resetPortalPropertiesStringArray(
2749                                            servletContextName, portalProperties, initPhase,
2750                                            propsValuesStringArray, stringArraysContainerMap, key,
2751                                            fieldName);
2752                            }
2753                            catch (Exception e) {
2754                                    _log.error(
2755                                            "Error setting field " + fieldName + ": " + e.getMessage());
2756                            }
2757                    }
2758            }
2759    
2760            protected void resetPortalPropertiesStringArray(
2761                            String servletContextName, Properties portalProperties,
2762                            boolean initPhase, String[] propsValuesStringArray,
2763                            Map<String, StringArraysContainer> stringArraysContainerMap,
2764                            String key, String fieldName)
2765                    throws Exception {
2766    
2767                    Field field = PropsValues.class.getField(fieldName);
2768    
2769                    StringArraysContainer stringArraysContainer =
2770                            stringArraysContainerMap.get(key);
2771    
2772                    String[] value = null;
2773    
2774                    if (initPhase) {
2775                            if (stringArraysContainer
2776                                            instanceof OverrideStringArraysContainer) {
2777    
2778                                    OverrideStringArraysContainer overrideStringArraysContainer =
2779                                            (OverrideStringArraysContainer)stringArraysContainer;
2780    
2781                                    if (overrideStringArraysContainer.isOverridden()) {
2782                                            _log.error("Error setting overridden field " + fieldName);
2783    
2784                                            return;
2785                                    }
2786    
2787                                    value = StringUtil.split(portalProperties.getProperty(key));
2788                            }
2789                            else {
2790                                    value = PropsUtil.getArray(key);
2791                            }
2792                    }
2793    
2794                    stringArraysContainer.setPluginStringArray(servletContextName, value);
2795    
2796                    value = stringArraysContainer.getStringArray();
2797    
2798                    if (stringArraysContainer instanceof MergeStringArraysContainer) {
2799                            Properties properties = new Properties();
2800    
2801                            String valueString = StringUtil.merge(value, StringPool.COMMA);
2802    
2803                            properties.setProperty(key, valueString);
2804    
2805                            PropsUtil.addProperties(properties);
2806                    }
2807    
2808                    field.set(null, value);
2809    
2810                    if (key.equals(PropsKeys.LAYOUT_TYPES)) {
2811                            Map<String, LayoutSettings> layoutSettingsMap =
2812                                    LayoutSettings.getLayoutSettingsMap();
2813    
2814                            Set<Map.Entry<String, LayoutSettings>> set =
2815                                    layoutSettingsMap.entrySet();
2816    
2817                            Iterator<Map.Entry<String, LayoutSettings>> iterator =
2818                                    set.iterator();
2819    
2820                            while (iterator.hasNext()) {
2821                                    Map.Entry<String, LayoutSettings> entry = iterator.next();
2822    
2823                                    String layoutType = entry.getKey();
2824    
2825                                    if (!layoutType.equals(LayoutConstants.TYPE_CONTROL_PANEL) &&
2826                                            !ArrayUtil.contains(value, layoutType)) {
2827    
2828                                            iterator.remove();
2829                                    }
2830                            }
2831    
2832                            for (String type : value) {
2833                                    if (!layoutSettingsMap.containsKey(type)) {
2834                                            LayoutSettings.addLayoutSetting(type);
2835                                    }
2836                            }
2837                    }
2838            }
2839    
2840            protected void updateRelease(
2841                            String servletContextName, ClassLoader portletClassLoader,
2842                            Properties unfilteredPortalProperties)
2843                    throws Exception {
2844    
2845                    int buildNumber = GetterUtil.getInteger(
2846                            unfilteredPortalProperties.getProperty(
2847                                    PropsKeys.RELEASE_INFO_BUILD_NUMBER));
2848    
2849                    if (buildNumber <= 0) {
2850                            _log.error(
2851                                    "Skipping upgrade processes for " + servletContextName +
2852                                            " because \"release.info.build.number\" is not specified");
2853    
2854                            return;
2855                    }
2856    
2857                    Release release = ReleaseLocalServiceUtil.fetchRelease(
2858                            servletContextName);
2859    
2860                    if (release == null) {
2861                            int previousBuildNumber = GetterUtil.getInteger(
2862                                    unfilteredPortalProperties.getProperty(
2863                                            PropsKeys.RELEASE_INFO_PREVIOUS_BUILD_NUMBER),
2864                                    buildNumber);
2865    
2866                            release = ReleaseLocalServiceUtil.addRelease(
2867                                    servletContextName, previousBuildNumber);
2868                    }
2869    
2870                    if (buildNumber == release.getBuildNumber()) {
2871                            if (_log.isDebugEnabled()) {
2872                                    _log.debug(
2873                                            "Skipping upgrade processes for " + servletContextName +
2874                                                    " because it is already up to date");
2875                            }
2876                    }
2877                    else if (buildNumber < release.getBuildNumber()) {
2878                            throw new UpgradeException(
2879                                    "Skipping upgrade processes for " + servletContextName +
2880                                            " because you are trying to upgrade with an older version");
2881                    }
2882                    else {
2883                            String[] upgradeProcessClassNames = StringUtil.split(
2884                                    unfilteredPortalProperties.getProperty(
2885                                            PropsKeys.UPGRADE_PROCESSES));
2886    
2887                            boolean indexOnUpgrade = GetterUtil.getBoolean(
2888                                    unfilteredPortalProperties.getProperty(
2889                                            PropsKeys.INDEX_ON_UPGRADE),
2890                                    PropsValues.INDEX_ON_UPGRADE);
2891    
2892                            UpgradeProcessUtil.upgradeProcess(
2893                                    release.getBuildNumber(), upgradeProcessClassNames,
2894                                    portletClassLoader, indexOnUpgrade);
2895                    }
2896    
2897                    ReleaseLocalServiceUtil.updateRelease(
2898                            release.getReleaseId(), buildNumber, null, true);
2899            }
2900    
2901            protected void verifyCustomJsps(
2902                            String servletContextName, CustomJspBag customJspBag)
2903                    throws DuplicateCustomJspException {
2904    
2905                    Set<String> customJsps = new HashSet<String>();
2906    
2907                    for (String customJsp : customJspBag.getCustomJsps()) {
2908                            String portalJsp = getPortalJsp(
2909                                    customJsp, customJspBag.getCustomJspDir());
2910    
2911                            customJsps.add(portalJsp);
2912                    }
2913    
2914                    Map<String, String> conflictingCustomJsps =
2915                            new HashMap<String, String>();
2916    
2917                    for (Map.Entry<String, CustomJspBag> entry :
2918                                    _customJspBagsMap.entrySet()) {
2919    
2920                            CustomJspBag currentCustomJspBag = entry.getValue();
2921    
2922                            if (!currentCustomJspBag.isCustomJspGlobal()) {
2923                                    continue;
2924                            }
2925    
2926                            String currentServletContextName = entry.getKey();
2927    
2928                            List<String> currentCustomJsps =
2929                                    currentCustomJspBag.getCustomJsps();
2930    
2931                            for (String currentCustomJsp : currentCustomJsps) {
2932                                    String currentPortalJsp = getPortalJsp(
2933                                            currentCustomJsp, currentCustomJspBag.getCustomJspDir());
2934    
2935                                    if (customJsps.contains(currentPortalJsp)) {
2936                                            conflictingCustomJsps.put(
2937                                                    currentPortalJsp, currentServletContextName);
2938                                    }
2939                            }
2940                    }
2941    
2942                    if (conflictingCustomJsps.isEmpty()) {
2943                            return;
2944                    }
2945    
2946                    _log.error(servletContextName + " conflicts with the installed hooks");
2947    
2948                    if (_log.isDebugEnabled()) {
2949                            Log log = SanitizerLogWrapper.allowCRLF(_log);
2950    
2951                            StringBundler sb = new StringBundler(
2952                                    conflictingCustomJsps.size() * 4 + 2);
2953    
2954                            sb.append("Colliding JSP files in ");
2955                            sb.append(servletContextName);
2956                            sb.append(StringPool.NEW_LINE);
2957    
2958                            int i = 0;
2959    
2960                            for (Map.Entry<String, String> entry :
2961                                            conflictingCustomJsps.entrySet()) {
2962    
2963                                    sb.append(entry.getKey());
2964                                    sb.append(" with ");
2965                                    sb.append(entry.getValue());
2966    
2967                                    if ((i + 1) < conflictingCustomJsps.size()) {
2968                                            sb.append(StringPool.NEW_LINE);
2969                                    }
2970    
2971                                    i++;
2972                            }
2973    
2974                            log.debug(sb.toString());
2975                    }
2976    
2977                    throw new DuplicateCustomJspException();
2978            }
2979    
2980            private static final String _RTL_HOOK_MODULE_GROUP_ID = "liferay";
2981    
2982            private static final String _RTL_HOOK_NAME = "RTL";
2983    
2984            private static final String _RTL_HOOK_TAG = "rtl";
2985    
2986            private static final String[] _PROPS_KEYS_EVENTS = {
2987                    LOGIN_EVENTS_POST, LOGIN_EVENTS_PRE, LOGOUT_EVENTS_POST,
2988                    LOGOUT_EVENTS_PRE, SERVLET_SERVICE_EVENTS_POST,
2989                    SERVLET_SERVICE_EVENTS_PRE
2990            };
2991    
2992            private static final String[] _PROPS_KEYS_SESSION_EVENTS = {
2993                    SERVLET_SESSION_CREATE_EVENTS, SERVLET_SESSION_DESTROY_EVENTS
2994            };
2995    
2996            private static final String[] _PROPS_VALUES_BOOLEAN = {
2997                    "auth.forward.by.last.path", "captcha.check.portal.create_account",
2998                    "dl.file.entry.drafts.enabled",
2999                    "dl.file.entry.open.in.ms.office.manual.check.in.required",
3000                    "dl.store.antivirus.enabled",
3001                    "field.enable.com.liferay.portal.model.Contact.birthday",
3002                    "field.enable.com.liferay.portal.model.Contact.male",
3003                    "field.enable.com.liferay.portal.model.Organization.status",
3004                    "javascript.fast.load", "layout.template.cache.enabled",
3005                    "layout.user.private.layouts.auto.create",
3006                    "layout.user.private.layouts.enabled",
3007                    "layout.user.private.layouts.power.user.required",
3008                    "layout.user.public.layouts.auto.create",
3009                    "layout.user.public.layouts.enabled",
3010                    "layout.user.public.layouts.power.user.required",
3011                    "login.create.account.allow.custom.password", "login.dialog.disabled",
3012                    "my.sites.show.private.sites.with.no.layouts",
3013                    "my.sites.show.public.sites.with.no.layouts",
3014                    "my.sites.show.user.private.sites.with.no.layouts",
3015                    "my.sites.show.user.public.sites.with.no.layouts",
3016                    "portlet.add.default.resource.check.enabled", "rss.feeds.enabled",
3017                    "session.store.password", "social.activity.sets.bundling.enabled",
3018                    "social.activity.sets.enabled", "terms.of.use.required",
3019                    "theme.css.fast.load", "theme.images.fast.load",
3020                    "theme.jsp.override.enabled", "theme.loader.new.theme.id.on.import",
3021                    "theme.portlet.decorate.default", "theme.portlet.sharing.default",
3022                    "user.notification.event.confirmation.enabled",
3023                    "users.email.address.required", "users.screen.name.always.autogenerate"
3024            };
3025    
3026            private static final String[] _PROPS_VALUES_INTEGER = {
3027                    "session.max.allowed", "users.image.max.height",
3028                    "users.image.max.width",
3029            };
3030    
3031            private static final String[] _PROPS_VALUES_LONG = {
3032            };
3033    
3034            private static final String[] _PROPS_VALUES_MERGE_STRING_ARRAY = {
3035                    "asset.publisher.query.form.configuration", "auth.token.ignore.actions",
3036                    "auth.token.ignore.origins", "auth.token.ignore.portlets",
3037                    "admin.default.group.names", "admin.default.role.names",
3038                    "admin.default.user.group.names", "asset.publisher.display.styles",
3039                    "company.settings.form.authentication",
3040                    "company.settings.form.configuration",
3041                    "company.settings.form.identification",
3042                    "company.settings.form.miscellaneous", "convert.processes",
3043                    "dockbar.add.portlets", "journal.article.form.add",
3044                    "journal.article.form.translate", "journal.article.form.update",
3045                    "layout.form.add", "layout.form.update", "layout.set.form.update",
3046                    "layout.static.portlets.all", "layout.types",
3047                    "login.form.navigation.post", "login.form.navigation.pre",
3048                    "organizations.form.add.identification", "organizations.form.add.main",
3049                    "organizations.form.add.miscellaneous",
3050                    "portlet.add.default.resource.check.whitelist",
3051                    "portlet.add.default.resource.check.whitelist.actions",
3052                    "portlet.interrupted.request.whitelist",
3053                    "portlet.interrupted.request.whitelist.actions",
3054                    "session.phishing.protected.attributes", "sites.form.add.advanced",
3055                    "sites.form.add.main", "sites.form.add.seo",
3056                    "sites.form.update.advanced", "sites.form.update.main",
3057                    "sites.form.update.seo", "staging.xstream.class.whitelist",
3058                    "users.form.add.identification", "users.form.add.main",
3059                    "users.form.add.miscellaneous", "users.form.my.account.identification",
3060                    "users.form.my.account.main", "users.form.my.account.miscellaneous",
3061                    "users.form.update.identification", "users.form.update.main",
3062                    "users.form.update.miscellaneous"
3063            };
3064    
3065            private static final String[] _PROPS_VALUES_OBSOLETE = {
3066                    "layout.user.private.layouts.modifiable",
3067                    "layout.user.public.layouts.modifiable"
3068            };
3069    
3070            private static final String[] _PROPS_VALUES_OVERRIDE_STRING_ARRAY = {
3071                    "locales.beta"
3072            };
3073    
3074            private static final String[] _PROPS_VALUES_STRING = {
3075                    "company.default.locale", "company.default.time.zone",
3076                    "default.landing.page.path", "default.regular.color.scheme.id",
3077                    "default.regular.theme.id", "default.wap.color.scheme.id",
3078                    "default.wap.theme.id", "passwords.passwordpolicytoolkit.generator",
3079                    "passwords.passwordpolicytoolkit.static",
3080                    "phone.number.format.international.regexp",
3081                    "phone.number.format.usa.regexp", "social.activity.sets.selector",
3082                    "theme.shortcut.icon"
3083            };
3084    
3085            private static Log _log = LogFactoryUtil.getLog(
3086                    HookHotDeployListener.class);
3087    
3088            private Map<String, AuthenticatorsContainer> _authenticatorsContainerMap =
3089                    new HashMap<String, AuthenticatorsContainer>();
3090            private Map<String, AuthFailuresContainer> _authFailuresContainerMap =
3091                    new HashMap<String, AuthFailuresContainer>();
3092            private Map<String, AuthPublicPathsContainer> _authPublicPathsContainerMap =
3093                    new HashMap<String, AuthPublicPathsContainer>();
3094            private Map<String, AuthVerifierConfigurationContainer>
3095                    _authVerifierConfigurationContainerMap =
3096                            new HashMap<String, AuthVerifierConfigurationContainer>();
3097            private Map<String, AutoDeployListenersContainer>
3098                    _autoDeployListenersContainerMap =
3099                            new HashMap<String, AutoDeployListenersContainer>();
3100            private Map<String, AutoLoginsContainer> _autoLoginsContainerMap =
3101                    new HashMap<String, AutoLoginsContainer>();
3102            private Map<String, CustomJspBag> _customJspBagsMap =
3103                    new HashMap<String, CustomJspBag>();
3104            private Map<String, DLFileEntryProcessorContainer>
3105                    _dlFileEntryProcessorContainerMap =
3106                            new HashMap<String, DLFileEntryProcessorContainer>();
3107            private Map<String, DLRepositoryContainer> _dlRepositoryContainerMap =
3108                    new HashMap<String, DLRepositoryContainer>();
3109            private Map<String, EventsContainer> _eventsContainerMap =
3110                    new HashMap<String, EventsContainer>();
3111            private Map<String, HotDeployListenersContainer>
3112                    _hotDeployListenersContainerMap =
3113                            new HashMap<String, HotDeployListenersContainer>();
3114            private Map<String, IndexerPostProcessorContainer>
3115                    _indexerPostProcessorContainerMap =
3116                            new HashMap<String, IndexerPostProcessorContainer>();
3117            private Map<String, LanguagesContainer> _languagesContainerMap =
3118                    new HashMap<String, LanguagesContainer>();
3119            private Map<String, LockListenerContainer> _lockListenerContainerMap =
3120                    new HashMap<String, LockListenerContainer>();
3121            private Map<String, StringArraysContainer> _mergeStringArraysContainerMap =
3122                    new HashMap<String, StringArraysContainer>();
3123            private Map<String, ModelListenersContainer> _modelListenersContainerMap =
3124                    new HashMap<String, ModelListenersContainer>();
3125            private Map<String, StringArraysContainer>
3126                    _overrideStringArraysContainerMap =
3127                            new HashMap<String, StringArraysContainer>();
3128            private Map<String, Properties> _portalPropertiesMap =
3129                    new HashMap<String, Properties>();
3130            private Set<String> _propsKeysEvents = SetUtil.fromArray(
3131                    _PROPS_KEYS_EVENTS);
3132            private Set<String> _propsKeysSessionEvents = SetUtil.fromArray(
3133                    _PROPS_KEYS_SESSION_EVENTS);
3134            private Map<String, SanitizerContainer> _sanitizerContainerMap =
3135                    new HashMap<String, SanitizerContainer>();
3136            private ServicesContainer _servicesContainer = new ServicesContainer();
3137            private Set<String> _servletContextNames = new HashSet<String>();
3138            private Map<String, ServletFiltersContainer> _servletFiltersContainerMap =
3139                    new HashMap<String, ServletFiltersContainer>();
3140            private Map<String, StrutsActionsContainer> _strutsActionsContainerMap =
3141                    new HashMap<String, StrutsActionsContainer>();
3142    
3143            private class AuthenticatorsContainer {
3144    
3145                    public void registerAuthenticator(
3146                            String key, Authenticator authenticator) {
3147    
3148                            List<Authenticator> authenticators = _authenticators.get(key);
3149    
3150                            if (authenticators == null) {
3151                                    authenticators = new ArrayList<Authenticator>();
3152    
3153                                    _authenticators.put(key, authenticators);
3154                            }
3155    
3156                            AuthPipeline.registerAuthenticator(key, authenticator);
3157    
3158                            authenticators.add(authenticator);
3159                    }
3160    
3161                    public void unregisterAuthenticators() {
3162                            for (Map.Entry<String, List<Authenticator>> entry :
3163                                            _authenticators.entrySet()) {
3164    
3165                                    String key = entry.getKey();
3166                                    List<Authenticator> authenticators = entry.getValue();
3167    
3168                                    for (Authenticator authenticator : authenticators) {
3169                                            AuthPipeline.unregisterAuthenticator(key, authenticator);
3170                                    }
3171                            }
3172                    }
3173    
3174                    private Map<String, List<Authenticator>> _authenticators =
3175                            new HashMap<String, List<Authenticator>>();
3176    
3177            }
3178    
3179            private class AuthFailuresContainer {
3180    
3181                    public void registerAuthFailure(String key, AuthFailure authFailure) {
3182                            List<AuthFailure> authFailures = _authFailures.get(key);
3183    
3184                            if (authFailures == null) {
3185                                    authFailures = new ArrayList<AuthFailure>();
3186    
3187                                    _authFailures.put(key, authFailures);
3188                            }
3189    
3190                            AuthPipeline.registerAuthFailure(key, authFailure);
3191    
3192                            authFailures.add(authFailure);
3193                    }
3194    
3195                    public void unregisterAuthFailures() {
3196                            for (Map.Entry<String, List<AuthFailure>> entry :
3197                                            _authFailures.entrySet()) {
3198    
3199                                    String key = entry.getKey();
3200                                    List<AuthFailure> authFailures = entry.getValue();
3201    
3202                                    for (AuthFailure authFailure : authFailures) {
3203                                            AuthPipeline.unregisterAuthFailure(key, authFailure);
3204                                    }
3205                            }
3206                    }
3207    
3208                    private Map<String, List<AuthFailure>> _authFailures =
3209                            new HashMap<String, List<AuthFailure>>();
3210    
3211            }
3212    
3213            private class AuthPublicPathsContainer {
3214    
3215                    public void registerPaths(String[] paths) {
3216                            for (String path : paths) {
3217                                    _paths.add(path);
3218                            }
3219    
3220                            AuthPublicPathRegistry.register(paths);
3221                    }
3222    
3223                    public void unregisterPaths() {
3224                            for (String path : _paths) {
3225                                    AuthPublicPathRegistry.unregister(path);
3226                            }
3227    
3228                            _paths.clear();
3229                    }
3230    
3231                    private Set<String> _paths = new HashSet<String>();
3232    
3233            }
3234    
3235            private class AuthVerifierConfigurationContainer {
3236    
3237                    public void registerAuthVerifierConfiguration(
3238                            AuthVerifierConfiguration authVerifierConfiguration) {
3239    
3240                            AuthVerifierPipeline.register(authVerifierConfiguration);
3241    
3242                            _authVerifierConfigurations.add(authVerifierConfiguration);
3243                    }
3244    
3245                    public void unregisterConfigurations() {
3246                            for (AuthVerifierConfiguration authVerifierConfiguration :
3247                                            _authVerifierConfigurations) {
3248    
3249                                    AuthVerifierPipeline.unregister(authVerifierConfiguration);
3250                            }
3251                    }
3252    
3253                    private List<AuthVerifierConfiguration> _authVerifierConfigurations =
3254                            new ArrayList<AuthVerifierConfiguration>();
3255    
3256            }
3257    
3258            private class AutoDeployListenersContainer {
3259    
3260                    public void registerAutoDeployListener(
3261                            AutoDeployListener autoDeployListener) {
3262    
3263                            AutoDeployDir autoDeployDir = AutoDeployUtil.getDir(
3264                                    AutoDeployDir.DEFAULT_NAME);
3265    
3266                            if (autoDeployDir == null) {
3267                                    return;
3268                            }
3269    
3270                            autoDeployDir.registerListener(autoDeployListener);
3271    
3272                            _autoDeployListeners.add(autoDeployListener);
3273                    }
3274    
3275                    public void unregisterAutoDeployListeners() {
3276                            AutoDeployDir autoDeployDir = AutoDeployUtil.getDir(
3277                                    AutoDeployDir.DEFAULT_NAME);
3278    
3279                            if (autoDeployDir == null) {
3280                                    return;
3281                            }
3282    
3283                            for (AutoDeployListener autoDeployListener : _autoDeployListeners) {
3284                                    autoDeployDir.unregisterListener(autoDeployListener);
3285                            }
3286                    }
3287    
3288                    private List<AutoDeployListener> _autoDeployListeners =
3289                            new ArrayList<AutoDeployListener>();
3290    
3291            }
3292    
3293            private class AutoLoginsContainer {
3294    
3295                    public void registerAutoLogin(AutoLogin autoLogin) {
3296                            AutoLoginFilter.registerAutoLogin(autoLogin);
3297    
3298                            _autoLogins.add(autoLogin);
3299                    }
3300    
3301                    public void unregisterAutoLogins() {
3302                            for (AutoLogin autoLogin : _autoLogins) {
3303                                    AutoLoginFilter.unregisterAutoLogin(autoLogin);
3304                            }
3305                    }
3306    
3307                    private List<AutoLogin> _autoLogins = new ArrayList<AutoLogin>();
3308    
3309            }
3310    
3311            private class CustomJspBag {
3312    
3313                    public CustomJspBag(
3314                            String customJspDir, boolean customJspGlobal,
3315                            List<String> customJsps) {
3316    
3317                            _customJspDir = customJspDir;
3318                            _customJspGlobal = customJspGlobal;
3319                            _customJsps = customJsps;
3320                    }
3321    
3322                    public String getCustomJspDir() {
3323                            return _customJspDir;
3324                    }
3325    
3326                    public List<String> getCustomJsps() {
3327                            return _customJsps;
3328                    }
3329    
3330                    public boolean isCustomJspGlobal() {
3331                            return _customJspGlobal;
3332                    }
3333    
3334                    private String _customJspDir;
3335                    private boolean _customJspGlobal;
3336                    private List<String> _customJsps;
3337    
3338            }
3339    
3340            private class DLFileEntryProcessorContainer {
3341    
3342                    public void registerDLProcessor(DLProcessor dlProcessor) {
3343                            DLProcessorRegistryUtil.register(dlProcessor);
3344    
3345                            _dlProcessors.add(dlProcessor);
3346                    }
3347    
3348                    public void unregisterDLProcessors() {
3349                            for (DLProcessor dlProcessor : _dlProcessors) {
3350                                    DLProcessorRegistryUtil.unregister(dlProcessor);
3351                            }
3352    
3353                            _dlProcessors.clear();
3354                    }
3355    
3356                    private List<DLProcessor> _dlProcessors = new ArrayList<DLProcessor>();
3357    
3358            }
3359    
3360            private class DLRepositoryContainer {
3361    
3362                    public void registerRepositoryFactory(
3363                            String className, RepositoryFactory repositoryFactory) {
3364    
3365                            RepositoryFactoryUtil.registerRepositoryFactory(
3366                                    className, repositoryFactory);
3367    
3368                            _classNames.add(className);
3369                    }
3370    
3371                    public void unregisterRepositoryFactories() {
3372                            for (String className : _classNames) {
3373                                    RepositoryFactoryUtil.unregisterRepositoryFactory(className);
3374                            }
3375    
3376                            _classNames.clear();
3377                    }
3378    
3379                    private List<String> _classNames = new ArrayList<String>();
3380    
3381            }
3382    
3383            private class EventsContainer {
3384    
3385                    public void registerEvent(String eventName, Object event) {
3386                            List<Object> events = _eventsMap.get(eventName);
3387    
3388                            if (events == null) {
3389                                    events = new ArrayList<Object>();
3390    
3391                                    _eventsMap.put(eventName, events);
3392                            }
3393    
3394                            events.add(event);
3395                    }
3396    
3397                    public void unregisterEvents() {
3398                            for (Map.Entry<String, List<Object>> entry :
3399                                            _eventsMap.entrySet()) {
3400    
3401                                    String eventName = entry.getKey();
3402                                    List<Object> events = entry.getValue();
3403    
3404                                    for (Object event : events) {
3405                                            EventsProcessorUtil.unregisterEvent(eventName, event);
3406                                    }
3407                            }
3408                    }
3409    
3410                    private Map<String, List<Object>> _eventsMap =
3411                            new HashMap<String, List<Object>>();
3412    
3413            }
3414    
3415            private class HotDeployListenersContainer {
3416    
3417                    public void registerHotDeployListener(
3418                            HotDeployListener hotDeployListener) {
3419    
3420                            HotDeployUtil.registerListener(hotDeployListener);
3421    
3422                            _hotDeployListeners.add(hotDeployListener);
3423                    }
3424    
3425                    public void unregisterHotDeployListeners() {
3426                            for (HotDeployListener hotDeployListener : _hotDeployListeners) {
3427                                    HotDeployUtil.unregisterListener(hotDeployListener);
3428                            }
3429                    }
3430    
3431                    private List<HotDeployListener> _hotDeployListeners =
3432                            new ArrayList<HotDeployListener>();
3433    
3434            }
3435    
3436            private class IndexerPostProcessorContainer {
3437    
3438                    public void registerIndexerPostProcessor(
3439                            String indexerClassName,
3440                            IndexerPostProcessor indexerPostProcessor) {
3441    
3442                            List<IndexerPostProcessor> indexerPostProcessors =
3443                                    _indexerPostProcessors.get(indexerClassName);
3444    
3445                            if (indexerPostProcessors == null) {
3446                                    indexerPostProcessors = new ArrayList<IndexerPostProcessor>();
3447    
3448                                    _indexerPostProcessors.put(
3449                                            indexerClassName, indexerPostProcessors);
3450                            }
3451    
3452                            indexerPostProcessors.add(indexerPostProcessor);
3453                    }
3454    
3455                    public void unregisterIndexerPostProcessor() {
3456                            for (Map.Entry<String, List<IndexerPostProcessor>> entry :
3457                                            _indexerPostProcessors.entrySet()) {
3458    
3459                                    String indexerClassName = entry.getKey();
3460                                    List<IndexerPostProcessor> indexerPostProcessors =
3461                                            entry.getValue();
3462    
3463                                    Indexer indexer = IndexerRegistryUtil.getIndexer(
3464                                            indexerClassName);
3465    
3466                                    for (IndexerPostProcessor indexerPostProcessor :
3467                                                    indexerPostProcessors) {
3468    
3469                                            indexer.unregisterIndexerPostProcessor(
3470                                                    indexerPostProcessor);
3471                                    }
3472                            }
3473                    }
3474    
3475                    private Map<String, List<IndexerPostProcessor>> _indexerPostProcessors =
3476                            new HashMap<String, List<IndexerPostProcessor>>();
3477    
3478            }
3479    
3480            private class LanguagesContainer {
3481    
3482                    public void addLanguage(
3483                            Locale locale, Map<String, String> languageMap) {
3484    
3485                            Map<String, String> oldLanguageMap =
3486                                    LanguageResources.putLanguageMap(locale, languageMap);
3487    
3488                            _languagesMap.put(locale, oldLanguageMap);
3489                    }
3490    
3491                    public void unregisterLanguages() {
3492                            for (Map.Entry<Locale, Map<String, String>> entry :
3493                                            _languagesMap.entrySet()) {
3494    
3495                                    Locale locale = entry.getKey();
3496                                    Map<String, String> languageMap = entry.getValue();
3497    
3498                                    LanguageResources.putLanguageMap(locale, languageMap);
3499                            }
3500                    }
3501    
3502                    private Map<Locale, Map<String, String>> _languagesMap =
3503                            new HashMap<Locale, Map<String, String>>();
3504    
3505            }
3506    
3507            private class LockListenerContainer {
3508    
3509                    public void registerLockListener(LockListener lockListener) {
3510                            LockListenerRegistryUtil.register(lockListener);
3511    
3512                            _lockListeners.add(lockListener);
3513                    }
3514    
3515                    public void unregisterLockListeners() {
3516                            for (LockListener lockListener : _lockListeners) {
3517                                    LockListenerRegistryUtil.unregister(lockListener);
3518                            }
3519    
3520                            _lockListeners.clear();
3521                    }
3522    
3523                    private List<LockListener> _lockListeners =
3524                            new ArrayList<LockListener>();
3525    
3526            }
3527    
3528            private class MergeStringArraysContainer implements StringArraysContainer {
3529    
3530                    private MergeStringArraysContainer(String key) {
3531                            _portalStringArray = PropsUtil.getArray(key);
3532                    }
3533    
3534                    @Override
3535                    public String[] getStringArray() {
3536                            List<String> mergedStringList = new UniqueList<String>();
3537    
3538                            mergedStringList.addAll(ListUtil.fromArray(_portalStringArray));
3539    
3540                            for (Map.Entry<String, String[]> entry :
3541                                            _pluginStringArrayMap.entrySet()) {
3542    
3543                                    String[] pluginStringArray = entry.getValue();
3544    
3545                                    mergedStringList.addAll(ListUtil.fromArray(pluginStringArray));
3546                            }
3547    
3548                            return mergedStringList.toArray(
3549                                    new String[mergedStringList.size()]);
3550                    }
3551    
3552                    @Override
3553                    public void setPluginStringArray(
3554                            String servletContextName, String[] pluginStringArray) {
3555    
3556                            if (pluginStringArray != null) {
3557                                    _pluginStringArrayMap.put(
3558                                            servletContextName, pluginStringArray);
3559                            }
3560                            else {
3561                                    _pluginStringArrayMap.remove(servletContextName);
3562                            }
3563                    }
3564    
3565                    private String[] _portalStringArray;
3566                    private Map<String, String[]> _pluginStringArrayMap =
3567                            new HashMap<String, String[]>();
3568    
3569            }
3570    
3571            private class ModelListenersContainer {
3572    
3573                    public void registerModelListener(
3574                            String modelName, ModelListener<BaseModel<?>> modelListener) {
3575    
3576                            List<ModelListener<BaseModel<?>>> modelListeners =
3577                                    _modelListenersMap.get(modelName);
3578    
3579                            if (modelListeners == null) {
3580                                    modelListeners = new ArrayList<ModelListener<BaseModel<?>>>();
3581    
3582                                    _modelListenersMap.put(modelName, modelListeners);
3583                            }
3584    
3585                            modelListeners.add(modelListener);
3586                    }
3587    
3588                    @SuppressWarnings("rawtypes")
3589                    public void unregisterModelListeners(String servletContextName) {
3590                            for (Map.Entry<String, List<ModelListener<BaseModel<?>>>> entry :
3591                                            _modelListenersMap.entrySet()) {
3592    
3593                                    String modelName = entry.getKey();
3594                                    List<ModelListener<BaseModel<?>>> modelListeners =
3595                                            entry.getValue();
3596    
3597                                    BasePersistence persistence = getPersistence(
3598                                            servletContextName, modelName);
3599    
3600                                    for (ModelListener<BaseModel<?>> modelListener :
3601                                                    modelListeners) {
3602    
3603                                            persistence.unregisterListener(modelListener);
3604                                    }
3605                            }
3606                    }
3607    
3608                    private Map<String, List<ModelListener<BaseModel<?>>>>
3609                            _modelListenersMap =
3610                                    new HashMap<String, List<ModelListener<BaseModel<?>>>>();
3611    
3612            }
3613    
3614            private class OverrideStringArraysContainer
3615                    implements StringArraysContainer {
3616    
3617                    private OverrideStringArraysContainer(String key) {
3618                            _portalStringArray = PropsUtil.getArray(key);
3619                    }
3620    
3621                    @Override
3622                    public String[] getStringArray() {
3623                            if (_pluginStringArray != null) {
3624                                    return _pluginStringArray;
3625                            }
3626    
3627                            return _portalStringArray;
3628                    }
3629    
3630                    public boolean isOverridden() {
3631                            if (Validator.isNotNull(_servletContextName)) {
3632                                    return true;
3633                            }
3634                            else {
3635                                    return false;
3636                            }
3637                    }
3638    
3639                    @Override
3640                    public void setPluginStringArray(
3641                            String servletContextName, String[] pluginStringArray) {
3642    
3643                            if (pluginStringArray != null) {
3644                                    if (!isOverridden()) {
3645                                            _servletContextName = servletContextName;
3646                                            _pluginStringArray = pluginStringArray;
3647                                    }
3648                            }
3649                            else {
3650                                    if (_servletContextName.equals(servletContextName)) {
3651                                            _servletContextName = null;
3652                                            _pluginStringArray = null;
3653                                    }
3654                            }
3655                    }
3656    
3657                    private String[] _pluginStringArray;
3658                    private String[] _portalStringArray;
3659                    private String _servletContextName;
3660    
3661            }
3662    
3663            private class SanitizerContainer {
3664    
3665                    public void registerSanitizer(Sanitizer sanitizer) {
3666                            _sanitizers.add(sanitizer);
3667    
3668                            SanitizerImpl sanitizerImpl =
3669                                    (SanitizerImpl)SanitizerUtil.getSanitizer();
3670    
3671                            sanitizerImpl.registerSanitizer(sanitizer);
3672                    }
3673    
3674                    public void unregisterSanitizers() {
3675                            SanitizerImpl sanitizerImpl =
3676                                    (SanitizerImpl)SanitizerUtil.getSanitizer();
3677    
3678                            for (Sanitizer sanitizer : _sanitizers) {
3679                                    sanitizerImpl.unregisterSanitizer(sanitizer);
3680                            }
3681                    }
3682    
3683                    private List<Sanitizer> _sanitizers = new ArrayList<Sanitizer>();
3684    
3685            }
3686    
3687            private class ServiceBag {
3688    
3689                    public ServiceBag(Object originalService) {
3690                            _originalService = originalService;
3691                    }
3692    
3693                    public void addCustomServiceConstructor(
3694                            String servletContextName, ClassLoader portletClassLoader,
3695                            Class<?> serviceTypeClass, Constructor<?> serviceImplConstructor) {
3696    
3697                            List<ServiceConstructor> serviceConstructors =
3698                                    _serviceConstructors.get(servletContextName);
3699    
3700                            if (serviceConstructors == null) {
3701                                    serviceConstructors = new ArrayList<ServiceConstructor>();
3702    
3703                                    _serviceConstructors.put(
3704                                            servletContextName, serviceConstructors);
3705                            }
3706    
3707                            ServiceConstructor serviceConstructor = new ServiceConstructor(
3708                                    portletClassLoader, serviceTypeClass, serviceImplConstructor);
3709    
3710                            serviceConstructors.add(serviceConstructor);
3711                    }
3712    
3713                    public Object getCustomService() throws Exception {
3714                            List<ServiceConstructor> serviceConstructors =
3715                                    new ArrayList<ServiceConstructor>();
3716    
3717                            for (Map.Entry<String, List<ServiceConstructor>> entry :
3718                                            _serviceConstructors.entrySet()) {
3719    
3720                                    serviceConstructors.addAll(entry.getValue());
3721                            }
3722    
3723                            Object customService = _originalService;
3724    
3725                            for (ServiceConstructor serviceConstructor : serviceConstructors) {
3726                                    ClassLoader portletClassLoader =
3727                                            serviceConstructor._portletClassLoader;
3728                                    Class<?> serviceTypeClass =
3729                                            serviceConstructor._serviceTypeClass;
3730                                    Constructor<?> serviceImplConstructor =
3731                                            serviceConstructor._serviceImplConstructor;
3732    
3733                                    customService = serviceImplConstructor.newInstance(
3734                                            customService);
3735    
3736                                    customService = ProxyUtil.newProxyInstance(
3737                                            portletClassLoader, new Class<?>[] {serviceTypeClass},
3738                                            new ClassLoaderBeanHandler(
3739                                                    customService, portletClassLoader));
3740                            }
3741    
3742                            if ((customService == _originalService) &&
3743                                    ProxyUtil.isProxyClass(customService.getClass())) {
3744    
3745                                    InvocationHandler invocationHandler =
3746                                            ProxyUtil.getInvocationHandler(customService);
3747    
3748                                    if (invocationHandler instanceof ClassLoaderBeanHandler) {
3749                                            ClassLoaderBeanHandler classLoaderBeanHandler =
3750                                                    (ClassLoaderBeanHandler)invocationHandler;
3751    
3752                                            customService = classLoaderBeanHandler.getBean();
3753                                    }
3754                            }
3755    
3756                            return customService;
3757                    }
3758    
3759                    private Object _originalService;
3760                    private Map<String, List<ServiceConstructor>> _serviceConstructors =
3761                            new HashMap<String, List<ServiceConstructor>>();
3762    
3763            }
3764    
3765            private class ServiceConstructor {
3766    
3767                    public ServiceConstructor(
3768                            ClassLoader portletClassLoader, Class<?> serviceTypeClass,
3769                            Constructor<?> serviceImplConstructor) {
3770    
3771                            _portletClassLoader = portletClassLoader;
3772                            _serviceTypeClass = serviceTypeClass;
3773                            _serviceImplConstructor = serviceImplConstructor;
3774                    }
3775    
3776                    private ClassLoader _portletClassLoader;
3777                    private Constructor<?> _serviceImplConstructor;
3778                    private Class<?> _serviceTypeClass;
3779    
3780            }
3781    
3782            private class ServicesContainer {
3783    
3784                    public void addServiceBag(
3785                            String servletContextName, ClassLoader portletClassLoader,
3786                            String serviceType, Class<?> serviceTypeClass,
3787                            Constructor<?> serviceImplConstructor, Object wrappedService) {
3788    
3789                            ServiceBag serviceBag = _serviceBags.get(serviceType);
3790    
3791                            if (serviceBag == null) {
3792                                    serviceBag = new ServiceBag(wrappedService);
3793    
3794                                    _serviceBags.put(serviceType, serviceBag);
3795                            }
3796    
3797                            serviceBag.addCustomServiceConstructor(
3798                                    servletContextName, portletClassLoader, serviceTypeClass,
3799                                    serviceImplConstructor);
3800                    }
3801    
3802                    private Map<String, ServiceBag> _serviceBags =
3803                            new HashMap<String, ServiceBag>();
3804    
3805            }
3806    
3807            private class ServletFiltersContainer {
3808    
3809                    public InvokerFilterHelper getInvokerFilterHelper() {
3810                            ServletContext portalServletContext = ServletContextPool.get(
3811                                    PortalUtil.getServletContextName());
3812    
3813                            InvokerFilterHelper invokerFilterHelper =
3814                                    (InvokerFilterHelper)portalServletContext.getAttribute(
3815                                            InvokerFilterHelper.class.getName());
3816    
3817                            return invokerFilterHelper;
3818                    }
3819    
3820                    public void registerFilter(
3821                            String filterName, Filter filter, FilterConfig filterConfig) {
3822    
3823                            InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3824    
3825                            Filter previousFilter = invokerFilterHelper.registerFilter(
3826                                    filterName, filter);
3827    
3828                            _filterConfigs.put(filterName, filterConfig);
3829                            _filters.put(filterName, previousFilter);
3830                    }
3831    
3832                    public void registerFilterMapping(
3833                            String filterName, List<String> urlPatterns,
3834                            List<String> dispatchers, String positionFilterName,
3835                            boolean after) {
3836    
3837                            InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3838    
3839                            Filter filter = invokerFilterHelper.getFilter(filterName);
3840    
3841                            FilterConfig filterConfig = _filterConfigs.get(filterName);
3842    
3843                            if (filterConfig == null) {
3844                                    filterConfig = invokerFilterHelper.getFilterConfig(filterName);
3845                            }
3846    
3847                            if (filter == null) {
3848                                    if (_log.isWarnEnabled()) {
3849                                            _log.warn(
3850                                                    "No filter exists with filter mapping " + filterName);
3851                                    }
3852    
3853                                    return;
3854                            }
3855    
3856                            FilterMapping filterMapping = new FilterMapping(
3857                                    filter, filterConfig, urlPatterns, dispatchers);
3858    
3859                            invokerFilterHelper.registerFilterMapping(
3860                                    filterMapping, positionFilterName, after);
3861                    }
3862    
3863                    public void unregisterFilterMappings() {
3864                            InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3865    
3866                            for (String filterName : _filters.keySet()) {
3867                                    Filter filter = _filters.get(filterName);
3868    
3869                                    Filter previousFilter = invokerFilterHelper.registerFilter(
3870                                            filterName, filter);
3871    
3872                                    previousFilter.destroy();
3873                            }
3874    
3875                            for (FilterMapping filterMapping : _filterMappings) {
3876                                    invokerFilterHelper.unregisterFilterMapping(filterMapping);
3877    
3878                                    filterMapping.setFilter(null);
3879                            }
3880                    }
3881    
3882                    private Map<String, FilterConfig> _filterConfigs =
3883                            new HashMap<String, FilterConfig>();
3884                    private List<FilterMapping> _filterMappings =
3885                            new ArrayList<FilterMapping>();
3886                    private Map<String, Filter> _filters = new HashMap<String, Filter>();
3887    
3888            }
3889    
3890            private interface StringArraysContainer {
3891    
3892                    public String[] getStringArray();
3893    
3894                    public void setPluginStringArray(
3895                            String servletContextName, String[] pluginStringArray);
3896    
3897            }
3898    
3899            private class StrutsActionsContainer {
3900    
3901                    public void registerStrutsAction(String path, Object strutsAction) {
3902                            if (strutsAction instanceof StrutsAction) {
3903                                    StrutsActionRegistryUtil.register(
3904                                            path, (StrutsAction)strutsAction);
3905                            }
3906                            else {
3907                                    StrutsActionRegistryUtil.register(
3908                                            path, (StrutsPortletAction)strutsAction);
3909                            }
3910    
3911                            _paths.add(path);
3912                    }
3913    
3914                    public void unregisterStrutsActions() {
3915                            for (String path : _paths) {
3916                                    StrutsActionRegistryUtil.unregister(path);
3917                            }
3918    
3919                            _paths.clear();
3920                    }
3921    
3922                    private List<String> _paths = new ArrayList<String>();
3923    
3924            }
3925    
3926    }