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