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