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