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