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