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