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    
953                    return locale;
954            }
955    
956            protected BasePersistence<?> getPersistence(String modelName) {
957                    int pos = modelName.lastIndexOf(CharPool.PERIOD);
958    
959                    String entityName = modelName.substring(pos + 1);
960    
961                    pos = modelName.lastIndexOf(".model.");
962    
963                    String packagePath = modelName.substring(0, pos);
964    
965                    return (BasePersistence<?>)PortalBeanLocatorUtil.locate(
966                            packagePath + ".service.persistence." + entityName + "Persistence");
967            }
968    
969            protected File getPortalJspBackupFile(File portalJspFile) {
970                    String fileName = portalJspFile.getName();
971                    String filePath = portalJspFile.toString();
972    
973                    int fileNameIndex = fileName.lastIndexOf(CharPool.PERIOD);
974    
975                    if (fileNameIndex > 0) {
976                            int filePathIndex = filePath.lastIndexOf(fileName);
977    
978                            fileName =
979                                    fileName.substring(0, fileNameIndex) + ".portal" +
980                                            fileName.substring(fileNameIndex);
981    
982                            filePath = filePath.substring(0, filePathIndex) + fileName;
983                    }
984                    else {
985                            filePath += ".portal";
986                    }
987    
988                    return new File(filePath);
989            }
990    
991            protected void initAuthenticators(
992                            ClassLoader portletClassLoader, Properties portalProperties,
993                            String key, AuthenticatorsContainer authenticatorsContainer)
994                    throws Exception {
995    
996                    String[] authenticatorClassNames = StringUtil.split(
997                            portalProperties.getProperty(key));
998    
999                    for (String authenticatorClassName : authenticatorClassNames) {
1000                            Authenticator authenticator = (Authenticator)newInstance(
1001                                    portletClassLoader, Authenticator.class,
1002                                    authenticatorClassName);
1003    
1004                            authenticatorsContainer.registerAuthenticator(key, authenticator);
1005                    }
1006            }
1007    
1008            protected void initAuthenticators(
1009                            String servletContextName, ClassLoader portletClassLoader,
1010                            Properties portalProperties)
1011                    throws Exception {
1012    
1013                    AuthenticatorsContainer authenticatorsContainer =
1014                            new AuthenticatorsContainer();
1015    
1016                    _authenticatorsContainerMap.put(
1017                            servletContextName, authenticatorsContainer);
1018    
1019                    initAuthenticators(
1020                            portletClassLoader, portalProperties, AUTH_PIPELINE_PRE,
1021                            authenticatorsContainer);
1022                    initAuthenticators(
1023                            portletClassLoader, portalProperties, AUTH_PIPELINE_POST,
1024                            authenticatorsContainer);
1025            }
1026    
1027            protected void initAuthFailures(
1028                            ClassLoader portletClassLoader, Properties portalProperties,
1029                            String key, AuthFailuresContainer authFailuresContainer)
1030                    throws Exception {
1031    
1032                    String[] authFailureClassNames = StringUtil.split(
1033                            portalProperties.getProperty(key));
1034    
1035                    for (String authFailureClassName : authFailureClassNames) {
1036                            AuthFailure authFailure = (AuthFailure)newInstance(
1037                                    portletClassLoader, AuthFailure.class, authFailureClassName);
1038    
1039                            authFailuresContainer.registerAuthFailure(key, authFailure);
1040                    }
1041            }
1042    
1043            protected void initAuthFailures(
1044                            String servletContextName, ClassLoader portletClassLoader,
1045                            Properties portalProperties)
1046                    throws Exception {
1047    
1048                    AuthFailuresContainer authFailuresContainer =
1049                            new AuthFailuresContainer();
1050    
1051                    _authFailuresContainerMap.put(
1052                            servletContextName, authFailuresContainer);
1053    
1054                    initAuthFailures(
1055                            portletClassLoader, portalProperties, AUTH_FAILURE,
1056                            authFailuresContainer);
1057                    initAuthFailures(
1058                            portletClassLoader, portalProperties, AUTH_MAX_FAILURES,
1059                            authFailuresContainer);
1060            }
1061    
1062            protected void initAuthPublicPaths(
1063                            String servletContextName, Properties portalProperties)
1064                    throws Exception {
1065    
1066                    AuthPublicPathsContainer authPublicPathsContainer =
1067                            new AuthPublicPathsContainer();
1068    
1069                    _authPublicPathsContainerMap.put(
1070                            servletContextName, authPublicPathsContainer);
1071    
1072                    String[] publicPaths = StringUtil.split(
1073                            portalProperties.getProperty(AUTH_PUBLIC_PATHS));
1074    
1075                    authPublicPathsContainer.registerPaths(publicPaths);
1076            }
1077    
1078            protected void initAuthVerifiers(
1079                            String servletContextName, ClassLoader portletClassLoader,
1080                            Properties portalProperties)
1081                    throws Exception {
1082    
1083                    AuthVerifierConfigurationContainer authVerifierConfigurationContainer =
1084                            new AuthVerifierConfigurationContainer();
1085    
1086                    _authVerifierConfigurationContainerMap.put(
1087                            servletContextName, authVerifierConfigurationContainer);
1088    
1089                    String[] authVerifierClassNames = StringUtil.split(
1090                            portalProperties.getProperty(AUTH_VERIFIER_PIPELINE));
1091    
1092                    for (String authVerifierClassName : authVerifierClassNames) {
1093                            AuthVerifierConfiguration authVerifierConfiguration =
1094                                    new AuthVerifierConfiguration();
1095    
1096                            AuthVerifier authVerifier = (AuthVerifier)newInstance(
1097                                    portletClassLoader, AuthVerifier.class, authVerifierClassName);
1098    
1099                            authVerifierConfiguration.setAuthVerifier(authVerifier);
1100    
1101                            authVerifierConfiguration.setAuthVerifierClassName(
1102                                    authVerifierClassName);
1103    
1104                            Properties properties = PropertiesUtil.getProperties(
1105                                    portalProperties,
1106                                    AuthVerifierPipeline.getAuthVerifierPropertyName(
1107                                            authVerifierClassName),
1108                                    true);
1109    
1110                            authVerifierConfiguration.setProperties(properties);
1111    
1112                            authVerifierConfigurationContainer.
1113                                    registerAuthVerifierConfiguration(authVerifierConfiguration);
1114                    }
1115            }
1116    
1117            protected void initAutoDeployListeners(
1118                            String servletContextName, ClassLoader portletClassLoader,
1119                            Properties portalProperties)
1120                    throws Exception {
1121    
1122                    String[] autoDeployListenerClassNames = StringUtil.split(
1123                            portalProperties.getProperty(PropsKeys.AUTO_DEPLOY_LISTENERS));
1124    
1125                    if (autoDeployListenerClassNames.length == 0) {
1126                            return;
1127                    }
1128    
1129                    AutoDeployListenersContainer autoDeployListenersContainer =
1130                            new AutoDeployListenersContainer();
1131    
1132                    _autoDeployListenersContainerMap.put(
1133                            servletContextName, autoDeployListenersContainer);
1134    
1135                    for (String autoDeployListenerClassName :
1136                                    autoDeployListenerClassNames) {
1137    
1138                            AutoDeployListener autoDeployListener =
1139                                    (AutoDeployListener)newInstance(
1140                                            portletClassLoader, AutoDeployListener.class,
1141                                            autoDeployListenerClassName);
1142    
1143                            autoDeployListenersContainer.registerAutoDeployListener(
1144                                    autoDeployListener);
1145                    }
1146            }
1147    
1148            protected void initAutoLogins(
1149                            String servletContextName, ClassLoader portletClassLoader,
1150                            Properties portalProperties)
1151                    throws Exception {
1152    
1153                    AutoLoginsContainer autoLoginsContainer = new AutoLoginsContainer();
1154    
1155                    _autoLoginsContainerMap.put(servletContextName, autoLoginsContainer);
1156    
1157                    String[] autoLoginClassNames = StringUtil.split(
1158                            portalProperties.getProperty(AUTO_LOGIN_HOOKS));
1159    
1160                    for (String autoLoginClassName : autoLoginClassNames) {
1161                            AutoLogin autoLogin = (AutoLogin)newInstance(
1162                                    portletClassLoader, AutoLogin.class, autoLoginClassName);
1163    
1164                            autoLoginsContainer.registerAutoLogin(autoLogin);
1165                    }
1166            }
1167    
1168            protected void initCustomJspBag(
1169                            String servletContextName, String displayName,
1170                            CustomJspBag customJspBag)
1171                    throws Exception {
1172    
1173                    String customJspDir = customJspBag.getCustomJspDir();
1174                    boolean customJspGlobal = customJspBag.isCustomJspGlobal();
1175                    List<String> customJsps = customJspBag.getCustomJsps();
1176    
1177                    String portalWebDir = PortalUtil.getPortalWebDir();
1178    
1179                    for (String customJsp : customJsps) {
1180                            int pos = customJsp.indexOf(customJspDir);
1181    
1182                            String portalJsp = customJsp.substring(pos + customJspDir.length());
1183    
1184                            if (customJspGlobal) {
1185                                    File portalJspFile = new File(portalWebDir + portalJsp);
1186                                    File portalJspBackupFile = getPortalJspBackupFile(
1187                                            portalJspFile);
1188    
1189                                    if (portalJspFile.exists() && !portalJspBackupFile.exists()) {
1190                                            FileUtil.copyFile(portalJspFile, portalJspBackupFile);
1191                                    }
1192                            }
1193                            else {
1194                                    portalJsp = CustomJspRegistryUtil.getCustomJspFileName(
1195                                            servletContextName, portalJsp);
1196                            }
1197    
1198                            FileUtil.copyFile(customJsp, portalWebDir + portalJsp);
1199                    }
1200    
1201                    if (!customJspGlobal) {
1202                            CustomJspRegistryUtil.registerServletContextName(
1203                                    servletContextName, displayName);
1204                    }
1205            }
1206    
1207            protected void initCustomJspDir(
1208                            ServletContext servletContext, String servletContextName,
1209                            ClassLoader portletClassLoader, PluginPackage pluginPackage,
1210                            Element rootElement)
1211                    throws Exception {
1212    
1213                    String customJspDir = rootElement.elementText("custom-jsp-dir");
1214    
1215                    if (Validator.isNull(customJspDir)) {
1216                            return;
1217                    }
1218    
1219                    if (!checkPermission(
1220                                    PACLConstants.PORTAL_HOOK_PERMISSION_CUSTOM_JSP_DIR,
1221                                    portletClassLoader, null, "Rejecting custom JSP directory")) {
1222    
1223                            return;
1224                    }
1225    
1226                    if (_log.isDebugEnabled()) {
1227                            _log.debug("Custom JSP directory: " + customJspDir);
1228                    }
1229    
1230                    boolean customJspGlobal = GetterUtil.getBoolean(
1231                            rootElement.elementText("custom-jsp-global"), true);
1232    
1233                    List<String> customJsps = new ArrayList<String>();
1234    
1235                    String webDir = servletContext.getRealPath(StringPool.SLASH);
1236    
1237                    getCustomJsps(servletContext, webDir, customJspDir, customJsps);
1238    
1239                    if (customJsps.isEmpty()) {
1240                            return;
1241                    }
1242    
1243                    CustomJspBag customJspBag = new CustomJspBag(
1244                            customJspDir, customJspGlobal, customJsps);
1245    
1246                    if (_log.isDebugEnabled()) {
1247                            StringBundler sb = new StringBundler(customJsps.size() * 2 + 1);
1248    
1249                            sb.append("Custom JSP files:\n");
1250    
1251                            for (String customJsp : customJsps) {
1252                                    sb.append(customJsp);
1253                                    sb.append(StringPool.NEW_LINE);
1254                            }
1255    
1256                            sb.setIndex(sb.index() - 1);
1257    
1258                            _log.debug(sb.toString());
1259                    }
1260    
1261                    _customJspBagsMap.put(servletContextName, customJspBag);
1262    
1263                    initCustomJspBag(
1264                            servletContextName, pluginPackage.getName(), customJspBag);
1265            }
1266    
1267            protected Object initEvent(
1268                            String eventName, String eventClassName,
1269                            ClassLoader portletClassLoader)
1270                    throws Exception {
1271    
1272                    if (eventName.equals(APPLICATION_STARTUP_EVENTS)) {
1273                            SimpleAction simpleAction =
1274                                    (SimpleAction)portletClassLoader.loadClass(
1275                                            eventClassName).newInstance();
1276    
1277                            simpleAction = new InvokerSimpleAction(
1278                                    simpleAction, portletClassLoader);
1279    
1280                            Long companyId = CompanyThreadLocal.getCompanyId();
1281    
1282                            try {
1283                                    long[] companyIds = PortalInstances.getCompanyIds();
1284    
1285                                    for (long curCompanyId : companyIds) {
1286                                            CompanyThreadLocal.setCompanyId(curCompanyId);
1287    
1288                                            simpleAction.run(
1289                                                    new String[] {String.valueOf(curCompanyId)});
1290                                    }
1291                            }
1292                            finally {
1293                                    CompanyThreadLocal.setCompanyId(companyId);
1294                            }
1295    
1296                            return null;
1297                    }
1298    
1299                    if (_propsKeysEvents.contains(eventName)) {
1300                            Action action = (Action)portletClassLoader.loadClass(
1301                                    eventClassName).newInstance();
1302    
1303                            action = new InvokerAction(action, portletClassLoader);
1304    
1305                            EventsProcessorUtil.registerEvent(eventName, action);
1306    
1307                            return action;
1308                    }
1309    
1310                    if (_propsKeysSessionEvents.contains(eventName)) {
1311                            SessionAction sessionAction =
1312                                    (SessionAction)portletClassLoader.loadClass(
1313                                            eventClassName).newInstance();
1314    
1315                            sessionAction = new InvokerSessionAction(
1316                                    sessionAction, portletClassLoader);
1317    
1318                            EventsProcessorUtil.registerEvent(eventName, sessionAction);
1319    
1320                            return sessionAction;
1321                    }
1322    
1323                    return null;
1324            }
1325    
1326            protected void initEvents(
1327                            String servletContextName, ClassLoader portletClassLoader,
1328                            Properties portalProperties)
1329                    throws Exception {
1330    
1331                    EventsContainer eventsContainer = new EventsContainer();
1332    
1333                    _eventsContainerMap.put(servletContextName, eventsContainer);
1334    
1335                    for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
1336                            String key = (String)entry.getKey();
1337    
1338                            if (!key.equals(APPLICATION_STARTUP_EVENTS) &&
1339                                    !_propsKeysEvents.contains(key) &&
1340                                    !_propsKeysSessionEvents.contains(key)) {
1341    
1342                                    continue;
1343                            }
1344    
1345                            String eventName = key;
1346                            String[] eventClassNames = StringUtil.split(
1347                                    (String)entry.getValue());
1348    
1349                            for (String eventClassName : eventClassNames) {
1350                                    Object obj = initEvent(
1351                                            eventName, eventClassName, portletClassLoader);
1352    
1353                                    if (obj == null) {
1354                                            continue;
1355                                    }
1356    
1357                                    eventsContainer.registerEvent(eventName, obj);
1358                            }
1359                    }
1360            }
1361    
1362            protected void initHotDeployListeners(
1363                            String servletContextName, ClassLoader portletClassLoader,
1364                            Properties portalProperties)
1365                    throws Exception {
1366    
1367                    String[] hotDeployListenerClassNames = StringUtil.split(
1368                            portalProperties.getProperty(PropsKeys.HOT_DEPLOY_LISTENERS));
1369    
1370                    if (hotDeployListenerClassNames.length == 0) {
1371                            return;
1372                    }
1373    
1374                    HotDeployListenersContainer hotDeployListenersContainer =
1375                            new HotDeployListenersContainer();
1376    
1377                    _hotDeployListenersContainerMap.put(
1378                            servletContextName, hotDeployListenersContainer);
1379    
1380                    for (String hotDeployListenerClassName : hotDeployListenerClassNames) {
1381                            HotDeployListener hotDeployListener =
1382                                    (HotDeployListener)newInstance(
1383                                            portletClassLoader, HotDeployListener.class,
1384                                            hotDeployListenerClassName);
1385    
1386                            hotDeployListenersContainer.registerHotDeployListener(
1387                                    hotDeployListener);
1388                    }
1389            }
1390    
1391            protected void initIndexerPostProcessors(
1392                            String servletContextName, ClassLoader portletClassLoader,
1393                            Element parentElement)
1394                    throws Exception {
1395    
1396                    IndexerPostProcessorContainer indexerPostProcessorContainer =
1397                            _indexerPostProcessorContainerMap.get(servletContextName);
1398    
1399                    if (indexerPostProcessorContainer == null) {
1400                            indexerPostProcessorContainer = new IndexerPostProcessorContainer();
1401    
1402                            _indexerPostProcessorContainerMap.put(
1403                                    servletContextName, indexerPostProcessorContainer);
1404                    }
1405    
1406                    List<Element> indexerPostProcessorElements = parentElement.elements(
1407                            "indexer-post-processor");
1408    
1409                    for (Element indexerPostProcessorElement :
1410                                    indexerPostProcessorElements) {
1411    
1412                            String indexerClassName = indexerPostProcessorElement.elementText(
1413                                    "indexer-class-name");
1414    
1415                            if (!checkPermission(
1416                                            PACLConstants.PORTAL_HOOK_PERMISSION_INDEXER,
1417                                            portletClassLoader, indexerClassName,
1418                                            "Rejecting indexer " + indexerClassName)) {
1419    
1420                                    continue;
1421                            }
1422    
1423                            String indexerPostProcessorImpl =
1424                                    indexerPostProcessorElement.elementText(
1425                                            "indexer-post-processor-impl");
1426    
1427                            Indexer indexer = IndexerRegistryUtil.getIndexer(indexerClassName);
1428    
1429                            if (indexer == null) {
1430                                    _log.error("No indexer for " + indexerClassName + " was found");
1431    
1432                                    continue;
1433                            }
1434    
1435                            IndexerPostProcessor indexerPostProcessor =
1436                                    (IndexerPostProcessor)InstanceFactory.newInstance(
1437                                            portletClassLoader, indexerPostProcessorImpl);
1438    
1439                            indexer.registerIndexerPostProcessor(indexerPostProcessor);
1440    
1441                            indexerPostProcessorContainer.registerIndexerPostProcessor(
1442                                    indexerClassName, indexerPostProcessor);
1443                    }
1444            }
1445    
1446            protected void initLanguageProperties(
1447                            String servletContextName, ClassLoader portletClassLoader,
1448                            Element parentElement)
1449                    throws Exception {
1450    
1451                    LanguagesContainer languagesContainer = new LanguagesContainer();
1452    
1453                    _languagesContainerMap.put(servletContextName, languagesContainer);
1454    
1455                    List<Element> languagePropertiesElements = parentElement.elements(
1456                            "language-properties");
1457    
1458                    Map<String, String> baseLanguageMap = null;
1459    
1460                    for (Element languagePropertiesElement : languagePropertiesElements) {
1461                            Properties properties = null;
1462    
1463                            String languagePropertiesLocation =
1464                                    languagePropertiesElement.getText();
1465    
1466                            Locale locale = getLocale(languagePropertiesLocation);
1467    
1468                            if (locale != null) {
1469                                    if (!checkPermission(
1470                                                    PACLConstants.
1471                                                            PORTAL_HOOK_PERMISSION_LANGUAGE_PROPERTIES_LOCALE,
1472                                                    portletClassLoader, locale,
1473                                                    "Rejecting locale " + locale)) {
1474    
1475                                            continue;
1476                                    }
1477                            }
1478    
1479                            try {
1480                                    URL url = portletClassLoader.getResource(
1481                                            languagePropertiesLocation);
1482    
1483                                    if (url == null) {
1484                                            continue;
1485                                    }
1486    
1487                                    InputStream is = url.openStream();
1488    
1489                                    properties = PropertiesUtil.load(is, StringPool.UTF8);
1490    
1491                                    is.close();
1492                            }
1493                            catch (Exception e) {
1494                                    _log.error("Unable to read " + languagePropertiesLocation, e);
1495    
1496                                    continue;
1497                            }
1498    
1499                            Map<String, String> languageMap = new HashMap<String, String>();
1500    
1501                            if (baseLanguageMap != null) {
1502                                    languageMap.putAll(baseLanguageMap);
1503                            }
1504    
1505                            for (Map.Entry<Object, Object> entry : properties.entrySet()) {
1506                                    String key = (String)entry.getKey();
1507                                    String value = (String)entry.getValue();
1508    
1509                                    value = LanguageResources.fixValue(value);
1510    
1511                                    languageMap.put(key, value);
1512                            }
1513    
1514                            if (locale != null) {
1515                                    languagesContainer.addLanguage(locale, languageMap);
1516                            }
1517                            else if (!languageMap.isEmpty()) {
1518                                    baseLanguageMap = languageMap;
1519                            }
1520                    }
1521    
1522                    if (baseLanguageMap != null) {
1523                            Locale locale = new Locale(StringPool.BLANK);
1524    
1525                            languagesContainer.addLanguage(locale, baseLanguageMap);
1526                    }
1527            }
1528    
1529            @SuppressWarnings("rawtypes")
1530            protected ModelListener<BaseModel<?>> initModelListener(
1531                            String modelName, String modelListenerClassName,
1532                            ClassLoader portletClassLoader)
1533                    throws Exception {
1534    
1535                    ModelListener<BaseModel<?>> modelListener =
1536                            (ModelListener<BaseModel<?>>)newInstance(
1537                                    portletClassLoader, ModelListener.class,
1538                                    modelListenerClassName);
1539    
1540                    BasePersistence persistence = getPersistence(modelName);
1541    
1542                    persistence.registerListener(modelListener);
1543    
1544                    return modelListener;
1545            }
1546    
1547            protected void initModelListeners(
1548                            String servletContextName, ClassLoader portletClassLoader,
1549                            Properties portalProperties)
1550                    throws Exception {
1551    
1552                    ModelListenersContainer modelListenersContainer =
1553                            new ModelListenersContainer();
1554    
1555                    _modelListenersContainerMap.put(
1556                            servletContextName, modelListenersContainer);
1557    
1558                    for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
1559                            String key = (String)entry.getKey();
1560    
1561                            if (!key.startsWith(VALUE_OBJECT_LISTENER)) {
1562                                    continue;
1563                            }
1564    
1565                            String modelName = key.substring(VALUE_OBJECT_LISTENER.length());
1566    
1567                            String[] modelListenerClassNames = StringUtil.split(
1568                                    (String)entry.getValue());
1569    
1570                            for (String modelListenerClassName : modelListenerClassNames) {
1571                                    ModelListener<BaseModel<?>> modelListener = initModelListener(
1572                                            modelName, modelListenerClassName, portletClassLoader);
1573    
1574                                    if (modelListener != null) {
1575                                            modelListenersContainer.registerModelListener(
1576                                                    modelName, modelListener);
1577                                    }
1578                            }
1579                    }
1580            }
1581    
1582            protected void initPortalProperties(
1583                            String servletContextName, ClassLoader portletClassLoader,
1584                            Element parentElement)
1585                    throws Exception {
1586    
1587                    String portalPropertiesLocation = parentElement.elementText(
1588                            "portal-properties");
1589    
1590                    if (Validator.isNull(portalPropertiesLocation)) {
1591                            return;
1592                    }
1593    
1594                    Configuration portalPropertiesConfiguration = null;
1595    
1596                    try {
1597                            String name = portalPropertiesLocation;
1598    
1599                            int pos = name.lastIndexOf(".properties");
1600    
1601                            if (pos != -1) {
1602                                    name = name.substring(0, pos);
1603                            }
1604    
1605                            portalPropertiesConfiguration =
1606                                    ConfigurationFactoryUtil.getConfiguration(
1607                                            portletClassLoader, name);
1608                    }
1609                    catch (Exception e) {
1610                            _log.error("Unable to read " + portalPropertiesLocation, e);
1611                    }
1612    
1613                    if (portalPropertiesConfiguration == null) {
1614                            return;
1615                    }
1616    
1617                    Properties portalProperties =
1618                            portalPropertiesConfiguration.getProperties();
1619    
1620                    if (portalProperties.isEmpty()) {
1621                            return;
1622                    }
1623    
1624                    Set<Object> set = portalProperties.keySet();
1625    
1626                    Iterator<Object> iterator = set.iterator();
1627    
1628                    while (iterator.hasNext()) {
1629                            String key = (String)iterator.next();
1630    
1631                            if (!checkPermission(
1632                                            PACLConstants.PORTAL_HOOK_PERMISSION_PORTAL_PROPERTIES_KEY,
1633                                            portletClassLoader, key,
1634                                            "Rejecting portal.properties key " + key)) {
1635    
1636                                    iterator.remove();
1637                            }
1638                    }
1639    
1640                    Properties unfilteredPortalProperties =
1641                            (Properties)portalProperties.clone();
1642    
1643                    portalProperties.remove(PropsKeys.RELEASE_INFO_BUILD_NUMBER);
1644                    portalProperties.remove(PropsKeys.RELEASE_INFO_PREVIOUS_BUILD_NUMBER);
1645                    portalProperties.remove(PropsKeys.UPGRADE_PROCESSES);
1646    
1647                    _portalPropertiesMap.put(servletContextName, portalProperties);
1648    
1649                    // Initialize properties, auto logins, model listeners, and events in
1650                    // that specific order. Events have to be loaded last because they may
1651                    // require model listeners to have been registered.
1652    
1653                    initPortalProperties(
1654                            servletContextName, portletClassLoader, portalProperties,
1655                            unfilteredPortalProperties);
1656                    initAuthFailures(
1657                            servletContextName, portletClassLoader, portalProperties);
1658                    initAutoDeployListeners(
1659                            servletContextName, portletClassLoader, portalProperties);
1660                    initAutoLogins(
1661                            servletContextName, portletClassLoader, portalProperties);
1662                    initAuthenticators(
1663                            servletContextName, portletClassLoader, portalProperties);
1664                    initAuthVerifiers(
1665                            servletContextName, portletClassLoader, portalProperties);
1666                    initHotDeployListeners(
1667                            servletContextName, portletClassLoader, portalProperties);
1668                    initModelListeners(
1669                            servletContextName, portletClassLoader, portalProperties);
1670                    initEvents(servletContextName, portletClassLoader, portalProperties);
1671            }
1672    
1673            protected void initPortalProperties(
1674                            String servletContextName, ClassLoader portletClassLoader,
1675                            Properties portalProperties, Properties unfilteredPortalProperties)
1676                    throws Exception {
1677    
1678                    PropsUtil.addProperties(portalProperties);
1679    
1680                    if (_log.isDebugEnabled() && portalProperties.containsKey(LOCALES)) {
1681                            _log.debug(
1682                                    "Portlet locales " + portalProperties.getProperty(LOCALES));
1683                            _log.debug("Merged locales " + PropsUtil.get(LOCALES));
1684                            _log.debug(
1685                                    "Merged locales array length " +
1686                                            PropsUtil.getArray(LOCALES).length);
1687                    }
1688    
1689                    for (String key : _PROPS_VALUES_OBSOLETE) {
1690                            if (_log.isInfoEnabled() && portalProperties.contains(key)) {
1691                                    _log.info("Portal property \"" + key + "\" is obsolete");
1692                            }
1693                    }
1694    
1695                    resetPortalProperties(servletContextName, portalProperties, true);
1696    
1697                    if (portalProperties.containsKey(PropsKeys.AUTH_PUBLIC_PATHS)) {
1698                            initAuthPublicPaths(servletContextName, portalProperties);
1699                    }
1700    
1701                    if (portalProperties.containsKey(PropsKeys.AUTH_TOKEN_IMPL)) {
1702                            String authTokenClassName = portalProperties.getProperty(
1703                                    PropsKeys.AUTH_TOKEN_IMPL);
1704    
1705                            AuthToken authToken = (AuthToken)newInstance(
1706                                    portletClassLoader, AuthToken.class, authTokenClassName);
1707    
1708                            AuthTokenWrapper authTokenWrapper =
1709                                    (AuthTokenWrapper)AuthTokenUtil.getAuthToken();
1710    
1711                            authTokenWrapper.setAuthToken(authToken);
1712                    }
1713    
1714                    if (portalProperties.containsKey(PropsKeys.CAPTCHA_ENGINE_IMPL)) {
1715                            String captchaClassName = portalProperties.getProperty(
1716                                    PropsKeys.CAPTCHA_ENGINE_IMPL);
1717    
1718                            Captcha captcha = (Captcha)newInstance(
1719                                    portletClassLoader, Captcha.class, captchaClassName);
1720    
1721                            CaptchaImpl captchaImpl = null;
1722    
1723                            Captcha currentCaptcha = CaptchaUtil.getCaptcha();
1724    
1725                            if (currentCaptcha instanceof DoPrivilegedBean) {
1726                                    DoPrivilegedBean doPrivilegedBean =
1727                                            (DoPrivilegedBean)currentCaptcha;
1728    
1729                                    captchaImpl = (CaptchaImpl)doPrivilegedBean.getActualBean();
1730                            }
1731                            else {
1732                                    captchaImpl = (CaptchaImpl)currentCaptcha;
1733                            }
1734    
1735                            captchaImpl.setCaptcha(captcha);
1736                    }
1737    
1738                    if (portalProperties.containsKey(
1739                                    PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS)) {
1740    
1741                            String controlPanelEntryClassName = portalProperties.getProperty(
1742                                    PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS);
1743    
1744                            ControlPanelEntry controlPanelEntry =
1745                                    (ControlPanelEntry)newInstance(
1746                                            portletClassLoader, ControlPanelEntry.class,
1747                                            controlPanelEntryClassName);
1748    
1749                            DefaultControlPanelEntryFactory.setInstance(controlPanelEntry);
1750                    }
1751    
1752                    if (portalProperties.containsKey(PropsKeys.DL_FILE_ENTRY_PROCESSORS)) {
1753                            String[] dlProcessorClassNames = StringUtil.split(
1754                                    portalProperties.getProperty(
1755                                            PropsKeys.DL_FILE_ENTRY_PROCESSORS));
1756    
1757                            DLFileEntryProcessorContainer dlFileEntryProcessorContainer =
1758                                    new DLFileEntryProcessorContainer();
1759    
1760                            _dlFileEntryProcessorContainerMap.put(
1761                                    servletContextName, dlFileEntryProcessorContainer);
1762    
1763                            for (String dlProcessorClassName : dlProcessorClassNames) {
1764                                    DLProcessor dlProcessor = (DLProcessor)newInstance(
1765                                            portletClassLoader, DLProcessor.class,
1766                                            dlProcessorClassName);
1767    
1768                                    dlFileEntryProcessorContainer.registerDLProcessor(dlProcessor);
1769                            }
1770                    }
1771    
1772                    if (portalProperties.containsKey(PropsKeys.DL_REPOSITORY_IMPL)) {
1773                            String[] dlRepositoryClassNames = StringUtil.split(
1774                                    portalProperties.getProperty(PropsKeys.DL_REPOSITORY_IMPL));
1775    
1776                            DLRepositoryContainer dlRepositoryContainer =
1777                                    new DLRepositoryContainer();
1778    
1779                            _dlRepositoryContainerMap.put(
1780                                    servletContextName, dlRepositoryContainer);
1781    
1782                            for (String dlRepositoryClassName : dlRepositoryClassNames) {
1783                                    RepositoryFactory repositoryFactory = new RepositoryFactoryImpl(
1784                                            dlRepositoryClassName, portletClassLoader);
1785    
1786                                    dlRepositoryContainer.registerRepositoryFactory(
1787                                            dlRepositoryClassName, repositoryFactory);
1788                            }
1789                    }
1790    
1791                    if (portalProperties.containsKey(PropsKeys.DL_STORE_ANTIVIRUS_IMPL)) {
1792                            String antivirusScannerClassName = portalProperties.getProperty(
1793                                    PropsKeys.DL_STORE_ANTIVIRUS_IMPL);
1794    
1795                            AntivirusScanner antivirusScanner = (AntivirusScanner)newInstance(
1796                                    portletClassLoader, AntivirusScanner.class,
1797                                    antivirusScannerClassName);
1798    
1799                            AntivirusScannerWrapper antivirusScannerWrapper =
1800                                    (AntivirusScannerWrapper)
1801                                            AntivirusScannerUtil.getAntivirusScanner();
1802    
1803                            antivirusScannerWrapper.setAntivirusScanner(antivirusScanner);
1804                    }
1805    
1806                    if (portalProperties.containsKey(PropsKeys.DL_STORE_IMPL)) {
1807                            String storeClassName = portalProperties.getProperty(
1808                                    PropsKeys.DL_STORE_IMPL);
1809    
1810                            Store store = (Store)newInstance(
1811                                    portletClassLoader, Store.class, storeClassName);
1812    
1813                            StoreFactory.setInstance(store);
1814                    }
1815    
1816                    if (portalProperties.containsKey(
1817                                    PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL)) {
1818    
1819                            String attributesTransformerClassName =
1820                                    portalProperties.getProperty(
1821                                            PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL);
1822    
1823                            AttributesTransformer attributesTransformer =
1824                                    (AttributesTransformer)newInstance(
1825                                            portletClassLoader, AttributesTransformer.class,
1826                                            attributesTransformerClassName);
1827    
1828                            AttributesTransformerFactory.setInstance(attributesTransformer);
1829                    }
1830    
1831                    if (portalProperties.containsKey(LOCK_LISTENERS)) {
1832                            LockListenerContainer lockListenerContainer =
1833                                    _lockListenerContainerMap.get(servletContextName);
1834    
1835                            if (lockListenerContainer == null) {
1836                                    lockListenerContainer = new LockListenerContainer();
1837    
1838                                    _lockListenerContainerMap.put(
1839                                            servletContextName, lockListenerContainer);
1840                            }
1841    
1842                            String[] lockListenerClassNames = StringUtil.split(
1843                                    portalProperties.getProperty(LOCK_LISTENERS));
1844    
1845                            for (String lockListenerClassName : lockListenerClassNames) {
1846                                    LockListener lockListener = (LockListener)newInstance(
1847                                            portletClassLoader, LockListener.class,
1848                                            lockListenerClassName);
1849    
1850                                    lockListenerContainer.registerLockListener(lockListener);
1851                            }
1852                    }
1853    
1854                    if (portalProperties.containsKey(PropsKeys.MAIL_HOOK_IMPL)) {
1855                            String mailHookClassName = portalProperties.getProperty(
1856                                    PropsKeys.MAIL_HOOK_IMPL);
1857    
1858                            com.liferay.mail.util.Hook mailHook =
1859                                    (com.liferay.mail.util.Hook)newInstance(
1860                                            portletClassLoader, com.liferay.mail.util.Hook.class,
1861                                            mailHookClassName);
1862    
1863                            com.liferay.mail.util.HookFactory.setInstance(mailHook);
1864                    }
1865    
1866                    if (portalProperties.containsKey(
1867                                    PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS)) {
1868    
1869                            String organizationMembershipPolicyClassName =
1870                                    portalProperties.getProperty(
1871                                            PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS);
1872    
1873                            OrganizationMembershipPolicyFactoryImpl
1874                                    organizationMembershipPolicyFactoryImpl =
1875                                            (OrganizationMembershipPolicyFactoryImpl)
1876                                                    OrganizationMembershipPolicyFactoryUtil.
1877                                                            getOrganizationMembershipPolicyFactory();
1878    
1879                            OrganizationMembershipPolicy organizationMembershipPolicy =
1880                                    (OrganizationMembershipPolicy)newInstance(
1881                                            portletClassLoader, OrganizationMembershipPolicy.class,
1882                                            organizationMembershipPolicyClassName);
1883    
1884                            organizationMembershipPolicyFactoryImpl.
1885                                    setOrganizationMembershipPolicy(organizationMembershipPolicy);
1886    
1887                            if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
1888                                    organizationMembershipPolicy.verifyPolicy();
1889                            }
1890                    }
1891    
1892                    if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_ROLES)) {
1893                            String roleMembershipPolicyClassName = portalProperties.getProperty(
1894                                    PropsKeys.MEMBERSHIP_POLICY_ROLES);
1895    
1896                            RoleMembershipPolicyFactoryImpl roleMembershipPolicyFactoryImpl =
1897                                    (RoleMembershipPolicyFactoryImpl)
1898                                            RoleMembershipPolicyFactoryUtil.
1899                                                    getRoleMembershipPolicyFactory();
1900    
1901                            RoleMembershipPolicy roleMembershipPolicy =
1902                                    (RoleMembershipPolicy)newInstance(
1903                                            portletClassLoader, RoleMembershipPolicy.class,
1904                                            roleMembershipPolicyClassName);
1905    
1906                            roleMembershipPolicyFactoryImpl.setRoleMembershipPolicy(
1907                                    roleMembershipPolicy);
1908    
1909                            if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
1910                                    roleMembershipPolicy.verifyPolicy();
1911                            }
1912                    }
1913    
1914                    if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_SITES)) {
1915                            String siteMembershipPolicyClassName = portalProperties.getProperty(
1916                                    PropsKeys.MEMBERSHIP_POLICY_SITES);
1917    
1918                            SiteMembershipPolicyFactoryImpl siteMembershipPolicyFactoryImpl =
1919                                    (SiteMembershipPolicyFactoryImpl)
1920                                            SiteMembershipPolicyFactoryUtil.
1921                                                    getSiteMembershipPolicyFactory();
1922    
1923                            SiteMembershipPolicy siteMembershipPolicy =
1924                                    (SiteMembershipPolicy)newInstance(
1925                                            portletClassLoader, SiteMembershipPolicy.class,
1926                                            siteMembershipPolicyClassName);
1927    
1928                            siteMembershipPolicyFactoryImpl.setSiteMembershipPolicy(
1929                                    siteMembershipPolicy);
1930    
1931                            if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
1932                                    siteMembershipPolicy.verifyPolicy();
1933                            }
1934                    }
1935    
1936                    if (portalProperties.containsKey(
1937                                    PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS)) {
1938    
1939                            String userGroupMembershipPolicyClassName =
1940                                    portalProperties.getProperty(
1941                                            PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS);
1942    
1943                            UserGroupMembershipPolicyFactoryImpl
1944                                    userGroupMembershipPolicyFactoryImpl =
1945                                            (UserGroupMembershipPolicyFactoryImpl)
1946                                                    UserGroupMembershipPolicyFactoryUtil.
1947                                                            getUserGroupMembershipPolicyFactory();
1948    
1949                            UserGroupMembershipPolicy userGroupMembershipPolicy =
1950                                    (UserGroupMembershipPolicy)newInstance(
1951                                            portletClassLoader, UserGroupMembershipPolicy.class,
1952                                            userGroupMembershipPolicyClassName);
1953    
1954                            userGroupMembershipPolicyFactoryImpl.setUserGroupMembershipPolicy(
1955                                    userGroupMembershipPolicy);
1956    
1957                            if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
1958                                    userGroupMembershipPolicy.verifyPolicy();
1959                            }
1960                    }
1961    
1962                    if (portalProperties.containsKey(PropsKeys.PASSWORDS_TOOLKIT)) {
1963                            String toolkitClassName = portalProperties.getProperty(
1964                                    PropsKeys.PASSWORDS_TOOLKIT);
1965    
1966                            Toolkit toolkit = (Toolkit)newInstance(
1967                                    portletClassLoader, Sanitizer.class, toolkitClassName);
1968    
1969                            ToolkitWrapper toolkitWrapper =
1970                                    (ToolkitWrapper)PwdToolkitUtil.getToolkit();
1971    
1972                            toolkitWrapper.setToolkit(toolkit);
1973                    }
1974    
1975                    if (portalProperties.containsKey(PropsKeys.PHONE_NUMBER_FORMAT_IMPL)) {
1976                            String phoneNumberFormatClassName = portalProperties.getProperty(
1977                                    PropsKeys.PHONE_NUMBER_FORMAT_IMPL);
1978    
1979                            PhoneNumberFormat phoneNumberFormat =
1980                                    (PhoneNumberFormat)newInstance(
1981                                            portletClassLoader, PhoneNumberFormat.class,
1982                                            phoneNumberFormatClassName);
1983    
1984                            PhoneNumberFormatWrapper phoneNumberFormatWrapper =
1985                                    (PhoneNumberFormatWrapper)
1986                                            PhoneNumberFormatUtil.getPhoneNumberFormat();
1987    
1988                            phoneNumberFormatWrapper.setPhoneNumberFormat(phoneNumberFormat);
1989                    }
1990    
1991                    if (portalProperties.containsKey(PropsKeys.SANITIZER_IMPL)) {
1992                            String[] sanitizerClassNames = StringUtil.split(
1993                                    portalProperties.getProperty(PropsKeys.SANITIZER_IMPL));
1994    
1995                            SanitizerContainer sanitizerContainer = new SanitizerContainer();
1996    
1997                            _sanitizerContainerMap.put(servletContextName, sanitizerContainer);
1998    
1999                            for (String sanitizerClassName : sanitizerClassNames) {
2000                                    Sanitizer sanitizer = (Sanitizer)newInstance(
2001                                            portletClassLoader, Sanitizer.class, sanitizerClassName);
2002    
2003                                    sanitizerContainer.registerSanitizer(sanitizer);
2004                            }
2005                    }
2006    
2007                    if (portalProperties.containsKey(
2008                                    PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR)) {
2009    
2010                            String emailAddressGeneratorClassName =
2011                                    portalProperties.getProperty(
2012                                            PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR);
2013    
2014                            EmailAddressGenerator emailAddressGenerator =
2015                                    (EmailAddressGenerator)newInstance(
2016                                            portletClassLoader, EmailAddressGenerator.class,
2017                                            emailAddressGeneratorClassName);
2018    
2019                            EmailAddressGeneratorFactory.setInstance(emailAddressGenerator);
2020                    }
2021    
2022                    if (portalProperties.containsKey(
2023                                    PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR)) {
2024    
2025                            String emailAddressValidatorClassName =
2026                                    portalProperties.getProperty(
2027                                            PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR);
2028    
2029                            EmailAddressValidator emailAddressValidator =
2030                                    (EmailAddressValidator)newInstance(
2031                                            portletClassLoader, EmailAddressValidator.class,
2032                                            emailAddressValidatorClassName);
2033    
2034                            EmailAddressValidatorFactory.setInstance(emailAddressValidator);
2035                    }
2036    
2037                    if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_GENERATOR)) {
2038                            String fullNameGeneratorClassName = portalProperties.getProperty(
2039                                    PropsKeys.USERS_FULL_NAME_GENERATOR);
2040    
2041                            FullNameGenerator fullNameGenerator =
2042                                    (FullNameGenerator)newInstance(
2043                                            portletClassLoader, FullNameGenerator.class,
2044                                            fullNameGeneratorClassName);
2045    
2046                            FullNameGeneratorFactory.setInstance(fullNameGenerator);
2047                    }
2048    
2049                    if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_VALIDATOR)) {
2050                            String fullNameValidatorClassName = portalProperties.getProperty(
2051                                    PropsKeys.USERS_FULL_NAME_VALIDATOR);
2052    
2053                            FullNameValidator fullNameValidator =
2054                                    (FullNameValidator)newInstance(
2055                                            portletClassLoader, FullNameValidator.class,
2056                                            fullNameValidatorClassName);
2057    
2058                            FullNameValidatorFactory.setInstance(fullNameValidator);
2059                    }
2060    
2061                    if (portalProperties.containsKey(
2062                                    PropsKeys.USERS_SCREEN_NAME_GENERATOR)) {
2063    
2064                            String screenNameGeneratorClassName = portalProperties.getProperty(
2065                                    PropsKeys.USERS_SCREEN_NAME_GENERATOR);
2066    
2067                            ScreenNameGenerator screenNameGenerator =
2068                                    (ScreenNameGenerator)newInstance(
2069                                            portletClassLoader, ScreenNameGenerator.class,
2070                                            screenNameGeneratorClassName);
2071    
2072                            ScreenNameGeneratorFactory.setInstance(screenNameGenerator);
2073                    }
2074    
2075                    if (portalProperties.containsKey(
2076                                    PropsKeys.USERS_SCREEN_NAME_VALIDATOR)) {
2077    
2078                            String screenNameValidatorClassName = portalProperties.getProperty(
2079                                    PropsKeys.USERS_SCREEN_NAME_VALIDATOR);
2080    
2081                            ScreenNameValidator screenNameValidator =
2082                                    (ScreenNameValidator)newInstance(
2083                                            portletClassLoader, ScreenNameValidator.class,
2084                                            screenNameValidatorClassName);
2085    
2086                            ScreenNameValidatorFactory.setInstance(screenNameValidator);
2087                    }
2088    
2089                    Set<String> liferayFilterClassNames =
2090                            LiferayFilterTracker.getClassNames();
2091    
2092                    for (String liferayFilterClassName : liferayFilterClassNames) {
2093                            if (!portalProperties.containsKey(liferayFilterClassName)) {
2094                                    continue;
2095                            }
2096    
2097                            boolean filterEnabled = GetterUtil.getBoolean(
2098                                    portalProperties.getProperty(liferayFilterClassName));
2099    
2100                            Set<LiferayFilter> liferayFilters =
2101                                    LiferayFilterTracker.getLiferayFilters(liferayFilterClassName);
2102    
2103                            for (LiferayFilter liferayFilter : liferayFilters) {
2104                                    liferayFilter.setFilterEnabled(filterEnabled);
2105                            }
2106                    }
2107    
2108                    if (unfilteredPortalProperties.containsKey(
2109                                    PropsKeys.RELEASE_INFO_BUILD_NUMBER) ||
2110                            unfilteredPortalProperties.containsKey(
2111                                    PropsKeys.UPGRADE_PROCESSES)) {
2112    
2113                            updateRelease(
2114                                    servletContextName, portletClassLoader,
2115                                    unfilteredPortalProperties);
2116                    }
2117            }
2118    
2119            protected void initServices(
2120                            String servletContextName, ClassLoader portletClassLoader,
2121                            String serviceType, Class<?> serviceTypeClass,
2122                            Constructor<?> serviceImplConstructor, Object serviceProxy)
2123                    throws Exception {
2124    
2125                    AdvisedSupport advisedSupport = ServiceBeanAopProxy.getAdvisedSupport(
2126                            serviceProxy);
2127    
2128                    TargetSource targetSource = advisedSupport.getTargetSource();
2129    
2130                    Object previousService = targetSource.getTarget();
2131    
2132                    if (ProxyUtil.isProxyClass(previousService.getClass())) {
2133                            InvocationHandler invocationHandler =
2134                                    ProxyUtil.getInvocationHandler(previousService);
2135    
2136                            if (invocationHandler instanceof ClassLoaderBeanHandler) {
2137                                    ClassLoaderBeanHandler classLoaderBeanHandler =
2138                                            (ClassLoaderBeanHandler)invocationHandler;
2139    
2140                                    previousService = classLoaderBeanHandler.getBean();
2141                            }
2142                    }
2143    
2144                    Object nextService = serviceImplConstructor.newInstance(
2145                            previousService);
2146    
2147                    Object nextTarget = ProxyUtil.newProxyInstance(
2148                            portletClassLoader, new Class<?>[] {serviceTypeClass},
2149                            new ClassLoaderBeanHandler(nextService, portletClassLoader));
2150    
2151                    TargetSource nextTargetSource = new SingletonTargetSource(nextTarget);
2152    
2153                    advisedSupport.setTargetSource(nextTargetSource);
2154    
2155                    _servicesContainer.addServiceBag(
2156                            servletContextName, portletClassLoader, serviceType,
2157                            serviceTypeClass, serviceImplConstructor, previousService);
2158    
2159                    ServiceBeanAopCacheManagerUtil.reset();
2160            }
2161    
2162            protected Filter initServletFilter(
2163                            String filterClassName, ClassLoader portletClassLoader)
2164                    throws Exception {
2165    
2166                    Filter filter = (Filter)InstanceFactory.newInstance(
2167                            portletClassLoader, filterClassName);
2168    
2169                    List<Class<?>> interfaces = new ArrayList<Class<?>>();
2170    
2171                    if (filter instanceof TryFilter) {
2172                            interfaces.add(TryFilter.class);
2173                    }
2174    
2175                    if (filter instanceof TryFinallyFilter) {
2176                            interfaces.add(TryFinallyFilter.class);
2177                    }
2178    
2179                    if (filter instanceof WrapHttpServletRequestFilter) {
2180                            interfaces.add(WrapHttpServletRequestFilter.class);
2181                    }
2182    
2183                    if (filter instanceof WrapHttpServletResponseFilter) {
2184                            interfaces.add(WrapHttpServletResponseFilter.class);
2185                    }
2186    
2187                    if (filter instanceof LiferayFilter) {
2188                            interfaces.add(LiferayFilter.class);
2189                    }
2190                    else {
2191                            interfaces.add(Filter.class);
2192                    }
2193    
2194                    filter = (Filter)ProxyUtil.newProxyInstance(
2195                            portletClassLoader,
2196                            interfaces.toArray(new Class[interfaces.size()]),
2197                            new ClassLoaderBeanHandler(filter, portletClassLoader));
2198    
2199                    return filter;
2200            }
2201    
2202            protected void initServletFilters(
2203                            ServletContext servletContext, String servletContextName,
2204                            ClassLoader portletClassLoader, Element parentElement)
2205                    throws Exception {
2206    
2207                    ServletFiltersContainer servletFiltersContainer =
2208                            _servletFiltersContainerMap.get(servletContextName);
2209    
2210                    if (servletFiltersContainer == null) {
2211                            servletFiltersContainer = new ServletFiltersContainer();
2212    
2213                            _servletFiltersContainerMap.put(
2214                                    servletContextName, servletFiltersContainer);
2215                    }
2216    
2217                    List<Element> servletFilterElements = parentElement.elements(
2218                            "servlet-filter");
2219    
2220                    if (!servletFilterElements.isEmpty() &&
2221                            !checkPermission(
2222                                    PACLConstants.PORTAL_HOOK_PERMISSION_SERVLET_FILTERS,
2223                                    portletClassLoader, null, "Rejecting servlet filters")) {
2224    
2225                            return;
2226                    }
2227    
2228                    for (Element servletFilterElement : servletFilterElements) {
2229                            String servletFilterName = servletFilterElement.elementText(
2230                                    "servlet-filter-name");
2231                            String servletFilterImpl = servletFilterElement.elementText(
2232                                    "servlet-filter-impl");
2233    
2234                            List<Element> initParamElements = servletFilterElement.elements(
2235                                    "init-param");
2236    
2237                            Map<String, String> initParameterMap =
2238                                    new HashMap<String, String>();
2239    
2240                            for (Element initParamElement : initParamElements) {
2241                                    String paramName = initParamElement.elementText("param-name");
2242                                    String paramValue = initParamElement.elementText("param-value");
2243    
2244                                    initParameterMap.put(paramName, paramValue);
2245                            }
2246    
2247                            Filter filter = initServletFilter(
2248                                    servletFilterImpl, portletClassLoader);
2249    
2250                            FilterConfig filterConfig = new InvokerFilterConfig(
2251                                    servletContext, servletFilterName, initParameterMap);
2252    
2253                            filter.init(filterConfig);
2254    
2255                            servletFiltersContainer.registerFilter(
2256                                    servletFilterName, filter, filterConfig);
2257                    }
2258    
2259                    List<Element> servletFilterMappingElements = parentElement.elements(
2260                            "servlet-filter-mapping");
2261    
2262                    for (Element servletFilterMappingElement :
2263                                    servletFilterMappingElements) {
2264    
2265                            String servletFilterName = servletFilterMappingElement.elementText(
2266                                    "servlet-filter-name");
2267                            String afterFilter = servletFilterMappingElement.elementText(
2268                                    "after-filter");
2269                            String beforeFilter = servletFilterMappingElement.elementText(
2270                                    "before-filter");
2271    
2272                            String positionFilterName = beforeFilter;
2273                            boolean after = false;
2274    
2275                            if (Validator.isNotNull(afterFilter)) {
2276                                    positionFilterName = afterFilter;
2277                                    after = true;
2278                            }
2279    
2280                            List<Element> urlPatternElements =
2281                                    servletFilterMappingElement.elements("url-pattern");
2282    
2283                            List<String> urlPatterns = new ArrayList<String>();
2284    
2285                            for (Element urlPatternElement : urlPatternElements) {
2286                                    String urlPattern = urlPatternElement.getTextTrim();
2287    
2288                                    urlPatterns.add(urlPattern);
2289                            }
2290    
2291                            List<Element> dispatcherElements =
2292                                    servletFilterMappingElement.elements("dispatcher");
2293    
2294                            List<String> dispatchers = new ArrayList<String>();
2295    
2296                            for (Element dispatcherElement : dispatcherElements) {
2297                                    String dispatcher = dispatcherElement.getTextTrim();
2298    
2299                                    dispatcher = dispatcher.toUpperCase();
2300    
2301                                    dispatchers.add(dispatcher);
2302                            }
2303    
2304                            servletFiltersContainer.registerFilterMapping(
2305                                    servletFilterName, urlPatterns, dispatchers, positionFilterName,
2306                                    after);
2307                    }
2308            }
2309    
2310            protected Object initStrutsAction(
2311                            String strutsActionClassName, ClassLoader portletClassLoader)
2312                    throws Exception {
2313    
2314                    Object strutsAction = InstanceFactory.newInstance(
2315                            portletClassLoader, strutsActionClassName);
2316    
2317                    if (strutsAction instanceof StrutsAction) {
2318                            return ProxyUtil.newProxyInstance(
2319                                    portletClassLoader, new Class[] {StrutsAction.class},
2320                                    new ClassLoaderBeanHandler(strutsAction, portletClassLoader));
2321                    }
2322                    else {
2323                            return ProxyUtil.newProxyInstance(
2324                                    portletClassLoader, new Class[] {StrutsPortletAction.class},
2325                                    new ClassLoaderBeanHandler(strutsAction, portletClassLoader));
2326                    }
2327            }
2328    
2329            protected void initStrutsActions(
2330                            String servletContextName, ClassLoader portletClassLoader,
2331                            Element parentElement)
2332                    throws Exception {
2333    
2334                    StrutsActionsContainer strutsActionContainer =
2335                            _strutsActionsContainerMap.get(servletContextName);
2336    
2337                    if (strutsActionContainer == null) {
2338                            strutsActionContainer = new StrutsActionsContainer();
2339    
2340                            _strutsActionsContainerMap.put(
2341                                    servletContextName, strutsActionContainer);
2342                    }
2343    
2344                    List<Element> strutsActionElements = parentElement.elements(
2345                            "struts-action");
2346    
2347                    for (Element strutsActionElement : strutsActionElements) {
2348                            String strutsActionPath = strutsActionElement.elementText(
2349                                    "struts-action-path");
2350    
2351                            if (!checkPermission(
2352                                            PACLConstants.PORTAL_HOOK_PERMISSION_STRUTS_ACTION_PATH,
2353                                            portletClassLoader, strutsActionPath,
2354                                            "Rejecting struts action path " + strutsActionPath)) {
2355    
2356                                    continue;
2357                            }
2358    
2359                            String strutsActionImpl = strutsActionElement.elementText(
2360                                    "struts-action-impl");
2361    
2362                            Object strutsAction = initStrutsAction(
2363                                    strutsActionImpl, portletClassLoader);
2364    
2365                            strutsActionContainer.registerStrutsAction(
2366                                    strutsActionPath, strutsAction);
2367                    }
2368            }
2369    
2370            protected void resetPortalProperties(
2371                            String servletContextName, Properties portalProperties,
2372                            boolean initPhase)
2373                    throws Exception {
2374    
2375                    for (String key : _PROPS_VALUES_BOOLEAN) {
2376                            String fieldName = StringUtil.replace(
2377                                    key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2378    
2379                            if (!containsKey(portalProperties, key)) {
2380                                    continue;
2381                            }
2382    
2383                            try {
2384                                    Field field = PropsValues.class.getField(fieldName);
2385    
2386                                    Boolean value = Boolean.valueOf(
2387                                            GetterUtil.getBoolean(PropsUtil.get(key)));
2388    
2389                                    field.setBoolean(null, value);
2390                            }
2391                            catch (Exception e) {
2392                                    _log.error(
2393                                            "Error setting field " + fieldName + ": " + e.getMessage());
2394                            }
2395                    }
2396    
2397                    for (String key : _PROPS_VALUES_INTEGER) {
2398                            String fieldName = StringUtil.replace(
2399                                    key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2400    
2401                            if (!containsKey(portalProperties, key)) {
2402                                    continue;
2403                            }
2404    
2405                            try {
2406                                    Field field = PropsValues.class.getField(fieldName);
2407    
2408                                    Integer value = Integer.valueOf(
2409                                            GetterUtil.getInteger(PropsUtil.get(key)));
2410    
2411                                    field.setInt(null, value);
2412                            }
2413                            catch (Exception e) {
2414                                    _log.error(
2415                                            "Error setting field " + fieldName + ": " + e.getMessage());
2416                            }
2417                    }
2418    
2419                    for (String key : _PROPS_VALUES_LONG) {
2420                            String fieldName = StringUtil.replace(
2421                                    key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2422    
2423                            if (!containsKey(portalProperties, key)) {
2424                                    continue;
2425                            }
2426    
2427                            try {
2428                                    Field field = PropsValues.class.getField(fieldName);
2429    
2430                                    Long value = Long.valueOf(
2431                                            GetterUtil.getLong(PropsUtil.get(key)));
2432    
2433                                    field.setLong(null, value);
2434                            }
2435                            catch (Exception e) {
2436                                    _log.error(
2437                                            "Error setting field " + fieldName + ": " + e.getMessage());
2438                            }
2439                    }
2440    
2441                    for (String key : _PROPS_VALUES_STRING) {
2442                            String fieldName = StringUtil.replace(
2443                                    key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2444    
2445                            if (!containsKey(portalProperties, key)) {
2446                                    continue;
2447                            }
2448    
2449                            try {
2450                                    Field field = PropsValues.class.getField(fieldName);
2451    
2452                                    String value = GetterUtil.getString(PropsUtil.get(key));
2453    
2454                                    field.set(null, value);
2455                            }
2456                            catch (Exception e) {
2457                                    _log.error(
2458                                            "Error setting field " + fieldName + ": " + e.getMessage());
2459                            }
2460                    }
2461    
2462                    resetPortalPropertiesStringArray(
2463                            servletContextName, portalProperties, initPhase,
2464                            _PROPS_VALUES_MERGE_STRING_ARRAY, _mergeStringArraysContainerMap);
2465    
2466                    resetPortalPropertiesStringArray(
2467                            servletContextName, portalProperties, initPhase,
2468                            _PROPS_VALUES_OVERRIDE_STRING_ARRAY,
2469                            _overrideStringArraysContainerMap);
2470    
2471                    if (containsKey(portalProperties, LOCALES) ||
2472                            containsKey(portalProperties, LOCALES_BETA)) {
2473    
2474                            PropsValues.LOCALES = PropsUtil.getArray(LOCALES);
2475    
2476                            LanguageUtil.init();
2477                    }
2478    
2479                    if (containsKey(portalProperties, LOCALES_ENABLED)) {
2480                            PropsValues.LOCALES_ENABLED = PropsUtil.getArray(LOCALES_ENABLED);
2481    
2482                            LanguageUtil.init();
2483                    }
2484    
2485                    if (containsKey(portalProperties, AUTH_TOKEN_IGNORE_ACTIONS)) {
2486                            AuthTokenWhitelistUtil.resetPortletCSRFWhitelistActions();
2487                    }
2488    
2489                    if (containsKey(portalProperties, AUTH_TOKEN_IGNORE_PORTLETS)) {
2490                            AuthTokenWhitelistUtil.resetPortletCSRFWhitelist();
2491                    }
2492    
2493                    if (containsKey(
2494                                    portalProperties,
2495                                    PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST)) {
2496    
2497                            AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
2498                    }
2499    
2500                    if (containsKey(
2501                                    portalProperties,
2502                                    PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST_ACTIONS)) {
2503    
2504                            AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
2505                    }
2506    
2507                    CacheUtil.clearCache();
2508    
2509                    JavaScriptBundleUtil.clearCache();
2510            }
2511    
2512            protected void resetPortalPropertiesStringArray(
2513                    String servletContextName, Properties portalProperties,
2514                    boolean initPhase, String[] propsValuesStringArray,
2515                    Map<String, StringArraysContainer> stringArraysContainerMap) {
2516    
2517                    for (String key : propsValuesStringArray) {
2518                            String fieldName = StringUtil.replace(
2519                                    key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2520    
2521                            if (!containsKey(portalProperties, key)) {
2522                                    continue;
2523                            }
2524    
2525                            try {
2526                                    resetPortalPropertiesStringArray(
2527                                            servletContextName, portalProperties, initPhase,
2528                                            propsValuesStringArray, stringArraysContainerMap, key,
2529                                            fieldName);
2530                            }
2531                            catch (Exception e) {
2532                                    _log.error(
2533                                            "Error setting field " + fieldName + ": " + e.getMessage());
2534                            }
2535                    }
2536            }
2537    
2538            protected void resetPortalPropertiesStringArray(
2539                            String servletContextName, Properties portalProperties,
2540                            boolean initPhase, String[] propsValuesStringArray,
2541                            Map<String, StringArraysContainer> stringArraysContainerMap,
2542                            String key, String fieldName)
2543                    throws Exception {
2544    
2545                    Field field = PropsValues.class.getField(fieldName);
2546    
2547                    StringArraysContainer stringArraysContainer =
2548                            stringArraysContainerMap.get(key);
2549    
2550                    String[] value = null;
2551    
2552                    if (initPhase) {
2553                            if (stringArraysContainer
2554                                            instanceof OverrideStringArraysContainer) {
2555    
2556                                    OverrideStringArraysContainer overrideStringArraysContainer =
2557                                            (OverrideStringArraysContainer)stringArraysContainer;
2558    
2559                                    if (overrideStringArraysContainer.isOverridden()) {
2560                                            _log.error("Error setting overridden field " + fieldName);
2561    
2562                                            return;
2563                                    }
2564    
2565                                    value = StringUtil.split(portalProperties.getProperty(key));
2566                            }
2567                            else {
2568                                    value = PropsUtil.getArray(key);
2569                            }
2570                    }
2571    
2572                    stringArraysContainer.setPluginStringArray(servletContextName, value);
2573    
2574                    value = stringArraysContainer.getStringArray();
2575    
2576                    field.set(null, value);
2577            }
2578    
2579            protected void updateRelease(
2580                            String servletContextName, ClassLoader portletClassLoader,
2581                            Properties unfilteredPortalProperties)
2582                    throws Exception {
2583    
2584                    int buildNumber = GetterUtil.getInteger(
2585                            unfilteredPortalProperties.getProperty(
2586                                    PropsKeys.RELEASE_INFO_BUILD_NUMBER));
2587    
2588                    if (buildNumber <= 0) {
2589                            _log.error(
2590                                    "Skipping upgrade processes for " + servletContextName +
2591                                            " because \"release.info.build.number\" is not specified");
2592    
2593                            return;
2594                    }
2595    
2596                    Release release = ReleaseLocalServiceUtil.fetchRelease(
2597                            servletContextName);
2598    
2599                    if (release == null) {
2600                            int previousBuildNumber = GetterUtil.getInteger(
2601                                    unfilteredPortalProperties.getProperty(
2602                                            PropsKeys.RELEASE_INFO_PREVIOUS_BUILD_NUMBER),
2603                                    buildNumber);
2604    
2605                            release = ReleaseLocalServiceUtil.addRelease(
2606                                    servletContextName, previousBuildNumber);
2607                    }
2608    
2609                    if (buildNumber == release.getBuildNumber()) {
2610                            if (_log.isDebugEnabled()) {
2611                                    _log.debug(
2612                                            "Skipping upgrade processes for " + servletContextName +
2613                                                    " because it is already up to date");
2614                            }
2615                    }
2616                    else if (buildNumber < release.getBuildNumber()) {
2617                            throw new UpgradeException(
2618                                    "Skipping upgrade processes for " + servletContextName +
2619                                            " because you are trying to upgrade with an older version");
2620                    }
2621                    else {
2622                            String[] upgradeProcessClassNames = StringUtil.split(
2623                                    unfilteredPortalProperties.getProperty(
2624                                            PropsKeys.UPGRADE_PROCESSES));
2625    
2626                            boolean indexOnUpgrade = GetterUtil.getBoolean(
2627                                    unfilteredPortalProperties.getProperty(
2628                                            PropsKeys.INDEX_ON_UPGRADE),
2629                                    PropsValues.INDEX_ON_UPGRADE);
2630    
2631                            UpgradeProcessUtil.upgradeProcess(
2632                                    release.getBuildNumber(), upgradeProcessClassNames,
2633                                    portletClassLoader, indexOnUpgrade);
2634                    }
2635    
2636                    ReleaseLocalServiceUtil.updateRelease(
2637                            release.getReleaseId(), buildNumber, null, true);
2638            }
2639    
2640            private static final String[] _PROPS_KEYS_EVENTS = {
2641                    LOGIN_EVENTS_POST, LOGIN_EVENTS_PRE, LOGOUT_EVENTS_POST,
2642                    LOGOUT_EVENTS_PRE, SERVLET_SERVICE_EVENTS_POST,
2643                    SERVLET_SERVICE_EVENTS_PRE
2644            };
2645    
2646            private static final String[] _PROPS_KEYS_SESSION_EVENTS = {
2647                    SERVLET_SESSION_CREATE_EVENTS, SERVLET_SESSION_DESTROY_EVENTS
2648            };
2649    
2650            private static final String[] _PROPS_VALUES_BOOLEAN = {
2651                    "auth.forward.by.last.path", "captcha.check.portal.create_account",
2652                    "dl.file.entry.drafts.enabled",
2653                    "dl.file.entry.open.in.ms.office.manual.check.in.required",
2654                    "field.enable.com.liferay.portal.model.Contact.birthday",
2655                    "field.enable.com.liferay.portal.model.Contact.male",
2656                    "field.enable.com.liferay.portal.model.Organization.status",
2657                    "javascript.fast.load", "layout.template.cache.enabled",
2658                    "layout.user.private.layouts.auto.create",
2659                    "layout.user.private.layouts.enabled",
2660                    "layout.user.private.layouts.power.user.required",
2661                    "layout.user.public.layouts.auto.create",
2662                    "layout.user.public.layouts.enabled",
2663                    "layout.user.public.layouts.power.user.required",
2664                    "login.create.account.allow.custom.password",
2665                    "my.sites.show.private.sites.with.no.layouts",
2666                    "my.sites.show.public.sites.with.no.layouts",
2667                    "my.sites.show.user.private.sites.with.no.layouts",
2668                    "my.sites.show.user.public.sites.with.no.layouts",
2669                    "portlet.add.default.resource.check.enabled", "rss.feeds.enabled",
2670                    "session.store.password", "social.activity.sets.bundling.enabled",
2671                    "social.activity.sets.enabled", "terms.of.use.required",
2672                    "theme.css.fast.load", "theme.images.fast.load",
2673                    "theme.jsp.override.enabled", "theme.loader.new.theme.id.on.import",
2674                    "theme.portlet.decorate.default", "theme.portlet.sharing.default",
2675                    "user.notification.event.confirmation.enabled",
2676                    "users.email.address.required", "users.screen.name.always.autogenerate"
2677            };
2678    
2679            private static final String[] _PROPS_VALUES_INTEGER = {
2680                    "session.max.allowed", "users.image.max.height",
2681                    "users.image.max.width",
2682            };
2683    
2684            private static final String[] _PROPS_VALUES_LONG = {
2685            };
2686    
2687            private static final String[] _PROPS_VALUES_MERGE_STRING_ARRAY = {
2688                    "auth.token.ignore.actions", "auth.token.ignore.portlets",
2689                    "admin.default.group.names", "admin.default.role.names",
2690                    "admin.default.user.group.names", "asset.publisher.display.styles",
2691                    "company.settings.form.authentication",
2692                    "company.settings.form.configuration",
2693                    "company.settings.form.identification",
2694                    "company.settings.form.miscellaneous", "convert.processes",
2695                    "dockbar.add.portlets", "journal.article.form.add",
2696                    "journal.article.form.translate", "journal.article.form.update",
2697                    "layout.form.add", "layout.form.update", "layout.set.form.update",
2698                    "layout.static.portlets.all", "layout.types",
2699                    "login.form.navigation.post", "login.form.navigation.pre",
2700                    "organizations.form.add.identification", "organizations.form.add.main",
2701                    "organizations.form.add.miscellaneous",
2702                    "portlet.add.default.resource.check.whitelist",
2703                    "portlet.add.default.resource.check.whitelist.actions",
2704                    "session.phishing.protected.attributes", "sites.form.add.advanced",
2705                    "sites.form.add.main", "sites.form.add.seo",
2706                    "sites.form.update.advanced", "sites.form.update.main",
2707                    "sites.form.update.seo", "users.form.add.identification",
2708                    "users.form.add.main", "users.form.add.miscellaneous",
2709                    "users.form.my.account.identification", "users.form.my.account.main",
2710                    "users.form.my.account.miscellaneous",
2711                    "users.form.update.identification", "users.form.update.main",
2712                    "users.form.update.miscellaneous"
2713            };
2714    
2715            private static final String[] _PROPS_VALUES_OBSOLETE = {
2716                    "layout.user.private.layouts.modifiable",
2717                    "layout.user.public.layouts.modifiable"
2718            };
2719    
2720            private static final String[] _PROPS_VALUES_OVERRIDE_STRING_ARRAY = {
2721                    "locales.beta"
2722            };
2723    
2724            private static final String[] _PROPS_VALUES_STRING = {
2725                    "company.default.locale", "company.default.time.zone",
2726                    "default.landing.page.path", "default.regular.color.scheme.id",
2727                    "default.regular.theme.id", "default.wap.color.scheme.id",
2728                    "default.wap.theme.id", "passwords.passwordpolicytoolkit.generator",
2729                    "passwords.passwordpolicytoolkit.static",
2730                    "phone.number.format.international.regexp",
2731                    "phone.number.format.usa.regexp", "social.activity.sets.selector",
2732                    "theme.shortcut.icon"
2733            };
2734    
2735            private static Log _log = LogFactoryUtil.getLog(
2736                    HookHotDeployListener.class);
2737    
2738            private Map<String, AuthenticatorsContainer> _authenticatorsContainerMap =
2739                    new HashMap<String, AuthenticatorsContainer>();
2740            private Map<String, AuthFailuresContainer> _authFailuresContainerMap =
2741                    new HashMap<String, AuthFailuresContainer>();
2742            private Map<String, AuthPublicPathsContainer> _authPublicPathsContainerMap =
2743                    new HashMap<String, AuthPublicPathsContainer>();
2744            private Map<String, AuthVerifierConfigurationContainer>
2745                    _authVerifierConfigurationContainerMap =
2746                            new HashMap<String, AuthVerifierConfigurationContainer>();
2747            private Map<String, AutoDeployListenersContainer>
2748                    _autoDeployListenersContainerMap =
2749                            new HashMap<String, AutoDeployListenersContainer>();
2750            private Map<String, AutoLoginsContainer> _autoLoginsContainerMap =
2751                    new HashMap<String, AutoLoginsContainer>();
2752            private Map<String, CustomJspBag> _customJspBagsMap =
2753                    new HashMap<String, CustomJspBag>();
2754            private Map<String, DLFileEntryProcessorContainer>
2755                    _dlFileEntryProcessorContainerMap =
2756                            new HashMap<String, DLFileEntryProcessorContainer>();
2757            private Map<String, DLRepositoryContainer> _dlRepositoryContainerMap =
2758                    new HashMap<String, DLRepositoryContainer>();
2759            private Map<String, EventsContainer> _eventsContainerMap =
2760                    new HashMap<String, EventsContainer>();
2761            private Map<String, HotDeployListenersContainer>
2762                    _hotDeployListenersContainerMap =
2763                            new HashMap<String, HotDeployListenersContainer>();
2764            private Map<String, IndexerPostProcessorContainer>
2765                    _indexerPostProcessorContainerMap =
2766                            new HashMap<String, IndexerPostProcessorContainer>();
2767            private Map<String, LanguagesContainer> _languagesContainerMap =
2768                    new HashMap<String, LanguagesContainer>();
2769            private Map<String, LockListenerContainer> _lockListenerContainerMap =
2770                    new HashMap<String, LockListenerContainer>();
2771            private Map<String, StringArraysContainer> _mergeStringArraysContainerMap =
2772                    new HashMap<String, StringArraysContainer>();
2773            private Map<String, ModelListenersContainer> _modelListenersContainerMap =
2774                    new HashMap<String, ModelListenersContainer>();
2775            private Map<String, StringArraysContainer>
2776                    _overrideStringArraysContainerMap =
2777                            new HashMap<String, StringArraysContainer>();
2778            private Map<String, Properties> _portalPropertiesMap =
2779                    new HashMap<String, Properties>();
2780            private Set<String> _propsKeysEvents = SetUtil.fromArray(
2781                    _PROPS_KEYS_EVENTS);
2782            private Set<String> _propsKeysSessionEvents = SetUtil.fromArray(
2783                    _PROPS_KEYS_SESSION_EVENTS);
2784            private Map<String, SanitizerContainer> _sanitizerContainerMap =
2785                    new HashMap<String, SanitizerContainer>();
2786            private ServicesContainer _servicesContainer = new ServicesContainer();
2787            private Set<String> _servletContextNames = new HashSet<String>();
2788            private Map<String, ServletFiltersContainer> _servletFiltersContainerMap =
2789                    new HashMap<String, ServletFiltersContainer>();
2790            private Map<String, StrutsActionsContainer> _strutsActionsContainerMap =
2791                    new HashMap<String, StrutsActionsContainer>();
2792    
2793            private class AuthenticatorsContainer {
2794    
2795                    public void registerAuthenticator(
2796                            String key, Authenticator authenticator) {
2797    
2798                            List<Authenticator> authenticators = _authenticators.get(key);
2799    
2800                            if (authenticators == null) {
2801                                    authenticators = new ArrayList<Authenticator>();
2802    
2803                                    _authenticators.put(key, authenticators);
2804                            }
2805    
2806                            AuthPipeline.registerAuthenticator(key, authenticator);
2807    
2808                            authenticators.add(authenticator);
2809                    }
2810    
2811                    public void unregisterAuthenticators() {
2812                            for (Map.Entry<String, List<Authenticator>> entry :
2813                                            _authenticators.entrySet()) {
2814    
2815                                    String key = entry.getKey();
2816                                    List<Authenticator> authenticators = entry.getValue();
2817    
2818                                    for (Authenticator authenticator : authenticators) {
2819                                            AuthPipeline.unregisterAuthenticator(key, authenticator);
2820                                    }
2821                            }
2822                    }
2823    
2824                    private Map<String, List<Authenticator>> _authenticators =
2825                            new HashMap<String, List<Authenticator>>();
2826    
2827            }
2828    
2829            private class AuthFailuresContainer {
2830    
2831                    public void registerAuthFailure(String key, AuthFailure authFailure) {
2832                            List<AuthFailure> authFailures = _authFailures.get(key);
2833    
2834                            if (authFailures == null) {
2835                                    authFailures = new ArrayList<AuthFailure>();
2836    
2837                                    _authFailures.put(key, authFailures);
2838                            }
2839    
2840                            AuthPipeline.registerAuthFailure(key, authFailure);
2841    
2842                            authFailures.add(authFailure);
2843                    }
2844    
2845                    public void unregisterAuthFailures() {
2846                            for (Map.Entry<String, List<AuthFailure>> entry :
2847                                            _authFailures.entrySet()) {
2848    
2849                                    String key = entry.getKey();
2850                                    List<AuthFailure> authFailures = entry.getValue();
2851    
2852                                    for (AuthFailure authFailure : authFailures) {
2853                                            AuthPipeline.unregisterAuthFailure(key, authFailure);
2854                                    }
2855                            }
2856                    }
2857    
2858                    private Map<String, List<AuthFailure>> _authFailures =
2859                            new HashMap<String, List<AuthFailure>>();
2860    
2861            }
2862    
2863            private class AuthPublicPathsContainer {
2864    
2865                    public void registerPaths(String[] paths) {
2866                            for (String path : paths) {
2867                                    _paths.add(path);
2868                            }
2869    
2870                            AuthPublicPathRegistry.register(paths);
2871                    }
2872    
2873                    public void unregisterPaths() {
2874                            for (String path : _paths) {
2875                                    AuthPublicPathRegistry.unregister(path);
2876                            }
2877    
2878                            _paths.clear();
2879                    }
2880    
2881                    private Set<String> _paths = new HashSet<String>();
2882    
2883            }
2884    
2885            private class AuthVerifierConfigurationContainer {
2886    
2887                    public void registerAuthVerifierConfiguration(
2888                            AuthVerifierConfiguration authVerifierConfiguration) {
2889    
2890                            AuthVerifierPipeline.register(authVerifierConfiguration);
2891    
2892                            _authVerifierConfigurations.add(authVerifierConfiguration);
2893                    }
2894    
2895                    public void unregisterConfigurations() {
2896                            for (AuthVerifierConfiguration authVerifierConfiguration :
2897                                            _authVerifierConfigurations) {
2898    
2899                                    AuthVerifierPipeline.unregister(authVerifierConfiguration);
2900                            }
2901                    }
2902    
2903                    private List<AuthVerifierConfiguration> _authVerifierConfigurations =
2904                            new ArrayList<AuthVerifierConfiguration>();
2905    
2906            }
2907    
2908            private class AutoDeployListenersContainer {
2909    
2910                    public void registerAutoDeployListener(
2911                            AutoDeployListener autoDeployListener) {
2912    
2913                            AutoDeployDir autoDeployDir = AutoDeployUtil.getDir(
2914                                    AutoDeployDir.DEFAULT_NAME);
2915    
2916                            if (autoDeployDir == null) {
2917                                    return;
2918                            }
2919    
2920                            autoDeployDir.registerListener(autoDeployListener);
2921    
2922                            _autoDeployListeners.add(autoDeployListener);
2923                    }
2924    
2925                    public void unregisterAutoDeployListeners() {
2926                            AutoDeployDir autoDeployDir = AutoDeployUtil.getDir(
2927                                    AutoDeployDir.DEFAULT_NAME);
2928    
2929                            if (autoDeployDir == null) {
2930                                    return;
2931                            }
2932    
2933                            for (AutoDeployListener autoDeployListener : _autoDeployListeners) {
2934                                    autoDeployDir.unregisterListener(autoDeployListener);
2935                            }
2936                    }
2937    
2938                    private List<AutoDeployListener> _autoDeployListeners =
2939                            new ArrayList<AutoDeployListener>();
2940    
2941            }
2942    
2943            private class AutoLoginsContainer {
2944    
2945                    public void registerAutoLogin(AutoLogin autoLogin) {
2946                            AutoLoginFilter.registerAutoLogin(autoLogin);
2947    
2948                            _autoLogins.add(autoLogin);
2949                    }
2950    
2951                    public void unregisterAutoLogins() {
2952                            for (AutoLogin autoLogin : _autoLogins) {
2953                                    AutoLoginFilter.unregisterAutoLogin(autoLogin);
2954                            }
2955                    }
2956    
2957                    private List<AutoLogin> _autoLogins = new ArrayList<AutoLogin>();
2958    
2959            }
2960    
2961            private class CustomJspBag {
2962    
2963                    public CustomJspBag(
2964                            String customJspDir, boolean customJspGlobal,
2965                            List<String> customJsps) {
2966    
2967                            _customJspDir = customJspDir;
2968                            _customJspGlobal = customJspGlobal;
2969                            _customJsps = customJsps;
2970                    }
2971    
2972                    public String getCustomJspDir() {
2973                            return _customJspDir;
2974                    }
2975    
2976                    public List<String> getCustomJsps() {
2977                            return _customJsps;
2978                    }
2979    
2980                    public boolean isCustomJspGlobal() {
2981                            return _customJspGlobal;
2982                    }
2983    
2984                    private String _customJspDir;
2985                    private boolean _customJspGlobal;
2986                    private List<String> _customJsps;
2987    
2988            }
2989    
2990            private class DLFileEntryProcessorContainer {
2991    
2992                    public void registerDLProcessor(DLProcessor dlProcessor) {
2993                            DLProcessorRegistryUtil.register(dlProcessor);
2994    
2995                            _dlProcessors.add(dlProcessor);
2996                    }
2997    
2998                    public void unregisterDLProcessors() {
2999                            for (DLProcessor dlProcessor : _dlProcessors) {
3000                                    DLProcessorRegistryUtil.unregister(dlProcessor);
3001                            }
3002    
3003                            _dlProcessors.clear();
3004                    }
3005    
3006                    private List<DLProcessor> _dlProcessors = new ArrayList<DLProcessor>();
3007    
3008            }
3009    
3010            private class DLRepositoryContainer {
3011    
3012                    public void registerRepositoryFactory(
3013                            String className, RepositoryFactory repositoryFactory) {
3014    
3015                            RepositoryFactoryUtil.registerRepositoryFactory(
3016                                    className, repositoryFactory);
3017    
3018                            _classNames.add(className);
3019                    }
3020    
3021                    public void unregisterRepositoryFactories() {
3022                            for (String className : _classNames) {
3023                                    RepositoryFactoryUtil.unregisterRepositoryFactory(className);
3024                            }
3025    
3026                            _classNames.clear();
3027                    }
3028    
3029                    private List<String> _classNames = new ArrayList<String>();
3030    
3031            }
3032    
3033            private class EventsContainer {
3034    
3035                    public void registerEvent(String eventName, Object event) {
3036                            List<Object> events = _eventsMap.get(eventName);
3037    
3038                            if (events == null) {
3039                                    events = new ArrayList<Object>();
3040    
3041                                    _eventsMap.put(eventName, events);
3042                            }
3043    
3044                            events.add(event);
3045                    }
3046    
3047                    public void unregisterEvents() {
3048                            for (Map.Entry<String, List<Object>> entry :
3049                                            _eventsMap.entrySet()) {
3050    
3051                                    String eventName = entry.getKey();
3052                                    List<Object> events = entry.getValue();
3053    
3054                                    for (Object event : events) {
3055                                            EventsProcessorUtil.unregisterEvent(eventName, event);
3056                                    }
3057                            }
3058                    }
3059    
3060                    private Map<String, List<Object>> _eventsMap =
3061                            new HashMap<String, List<Object>>();
3062    
3063            }
3064    
3065            private class HotDeployListenersContainer {
3066    
3067                    public void registerHotDeployListener(
3068                            HotDeployListener hotDeployListener) {
3069    
3070                            HotDeployUtil.registerListener(hotDeployListener);
3071    
3072                            _hotDeployListeners.add(hotDeployListener);
3073                    }
3074    
3075                    public void unregisterHotDeployListeners() {
3076                            for (HotDeployListener hotDeployListener : _hotDeployListeners) {
3077                                    HotDeployUtil.unregisterListener(hotDeployListener);
3078                            }
3079                    }
3080    
3081                    private List<HotDeployListener> _hotDeployListeners =
3082                            new ArrayList<HotDeployListener>();
3083    
3084            }
3085    
3086            private class IndexerPostProcessorContainer {
3087    
3088                    public void registerIndexerPostProcessor(
3089                            String indexerClassName,
3090                            IndexerPostProcessor indexerPostProcessor) {
3091    
3092                            List<IndexerPostProcessor> indexerPostProcessors =
3093                                    _indexerPostProcessors.get(indexerClassName);
3094    
3095                            if (indexerPostProcessors == null) {
3096                                    indexerPostProcessors = new ArrayList<IndexerPostProcessor>();
3097    
3098                                    _indexerPostProcessors.put(
3099                                            indexerClassName, indexerPostProcessors);
3100                            }
3101    
3102                            indexerPostProcessors.add(indexerPostProcessor);
3103                    }
3104    
3105                    public void unregisterIndexerPostProcessor() {
3106                            for (Map.Entry<String, List<IndexerPostProcessor>> entry :
3107                                            _indexerPostProcessors.entrySet()) {
3108    
3109                                    String indexerClassName = entry.getKey();
3110                                    List<IndexerPostProcessor> indexerPostProcessors =
3111                                            entry.getValue();
3112    
3113                                    Indexer indexer = IndexerRegistryUtil.getIndexer(
3114                                            indexerClassName);
3115    
3116                                    for (IndexerPostProcessor indexerPostProcessor :
3117                                                    indexerPostProcessors) {
3118    
3119                                            indexer.unregisterIndexerPostProcessor(
3120                                                    indexerPostProcessor);
3121                                    }
3122                            }
3123                    }
3124    
3125                    private Map<String, List<IndexerPostProcessor>> _indexerPostProcessors =
3126                            new HashMap<String, List<IndexerPostProcessor>>();
3127    
3128            }
3129    
3130            private class LanguagesContainer {
3131    
3132                    public void addLanguage(
3133                            Locale locale, Map<String, String> languageMap) {
3134    
3135                            Map<String, String> oldLanguageMap =
3136                                    LanguageResources.putLanguageMap(locale, languageMap);
3137    
3138                            _languagesMap.put(locale, oldLanguageMap);
3139                    }
3140    
3141                    public void unregisterLanguages() {
3142                            for (Map.Entry<Locale, Map<String, String>> entry :
3143                                            _languagesMap.entrySet()) {
3144    
3145                                    Locale locale = entry.getKey();
3146                                    Map<String, String> languageMap = entry.getValue();
3147    
3148                                    LanguageResources.putLanguageMap(locale, languageMap);
3149                            }
3150                    }
3151    
3152                    private Map<Locale, Map<String, String>> _languagesMap =
3153                            new HashMap<Locale, Map<String, String>>();
3154    
3155            }
3156    
3157            private class LockListenerContainer {
3158    
3159                    public void registerLockListener(LockListener lockListener) {
3160                            LockListenerRegistryUtil.register(lockListener);
3161    
3162                            _lockListeners.add(lockListener);
3163                    }
3164    
3165                    public void unregisterLockListeners() {
3166                            for (LockListener lockListener : _lockListeners) {
3167                                    LockListenerRegistryUtil.unregister(lockListener);
3168                            }
3169    
3170                            _lockListeners.clear();
3171                    }
3172    
3173                    private List<LockListener> _lockListeners =
3174                            new ArrayList<LockListener>();
3175    
3176            }
3177    
3178            private class MergeStringArraysContainer implements StringArraysContainer {
3179    
3180                    private MergeStringArraysContainer(String key) {
3181                            _portalStringArray = PropsUtil.getArray(key);
3182                    }
3183    
3184                    @Override
3185                    public String[] getStringArray() {
3186                            List<String> mergedStringList = new UniqueList<String>();
3187    
3188                            mergedStringList.addAll(ListUtil.fromArray(_portalStringArray));
3189    
3190                            for (Map.Entry<String, String[]> entry :
3191                                            _pluginStringArrayMap.entrySet()) {
3192    
3193                                    String[] pluginStringArray = entry.getValue();
3194    
3195                                    mergedStringList.addAll(ListUtil.fromArray(pluginStringArray));
3196                            }
3197    
3198                            return mergedStringList.toArray(
3199                                    new String[mergedStringList.size()]);
3200                    }
3201    
3202                    @Override
3203                    public void setPluginStringArray(
3204                            String servletContextName, String[] pluginStringArray) {
3205    
3206                            if (pluginStringArray != null) {
3207                                    _pluginStringArrayMap.put(
3208                                            servletContextName, pluginStringArray);
3209                            }
3210                            else {
3211                                    _pluginStringArrayMap.remove(servletContextName);
3212                            }
3213                    }
3214    
3215                    private String[] _portalStringArray;
3216                    private Map<String, String[]> _pluginStringArrayMap =
3217                            new HashMap<String, String[]>();
3218    
3219            }
3220    
3221            private class ModelListenersContainer {
3222    
3223                    public void registerModelListener(
3224                            String modelName, ModelListener<BaseModel<?>> modelListener) {
3225    
3226                            List<ModelListener<BaseModel<?>>> modelListeners =
3227                                    _modelListenersMap.get(modelName);
3228    
3229                            if (modelListeners == null) {
3230                                    modelListeners = new ArrayList<ModelListener<BaseModel<?>>>();
3231    
3232                                    _modelListenersMap.put(modelName, modelListeners);
3233                            }
3234    
3235                            modelListeners.add(modelListener);
3236                    }
3237    
3238                    @SuppressWarnings("rawtypes")
3239                    public void unregisterModelListeners() {
3240                            for (Map.Entry<String, List<ModelListener<BaseModel<?>>>> entry :
3241                                            _modelListenersMap.entrySet()) {
3242    
3243                                    String modelName = entry.getKey();
3244                                    List<ModelListener<BaseModel<?>>> modelListeners =
3245                                            entry.getValue();
3246    
3247                                    BasePersistence persistence = getPersistence(modelName);
3248    
3249                                    for (ModelListener<BaseModel<?>> modelListener :
3250                                                    modelListeners) {
3251    
3252                                            persistence.unregisterListener(modelListener);
3253                                    }
3254                            }
3255                    }
3256    
3257                    private Map<String, List<ModelListener<BaseModel<?>>>>
3258                            _modelListenersMap =
3259                                    new HashMap<String, List<ModelListener<BaseModel<?>>>>();
3260    
3261            }
3262    
3263            private class OverrideStringArraysContainer
3264                    implements StringArraysContainer {
3265    
3266                    private OverrideStringArraysContainer(String key) {
3267                            _portalStringArray = PropsUtil.getArray(key);
3268                    }
3269    
3270                    @Override
3271                    public String[] getStringArray() {
3272                            if (_pluginStringArray != null) {
3273                                    return _pluginStringArray;
3274                            }
3275    
3276                            return _portalStringArray;
3277                    }
3278    
3279                    public boolean isOverridden() {
3280                            if (Validator.isNotNull(_servletContextName)) {
3281                                    return true;
3282                            }
3283                            else {
3284                                    return false;
3285                            }
3286                    }
3287    
3288                    @Override
3289                    public void setPluginStringArray(
3290                            String servletContextName, String[] pluginStringArray) {
3291    
3292                            if (pluginStringArray != null) {
3293                                    if (!isOverridden()) {
3294                                            _servletContextName = servletContextName;
3295                                            _pluginStringArray = pluginStringArray;
3296                                    }
3297                            }
3298                            else {
3299                                    if (_servletContextName.equals(servletContextName)) {
3300                                            _servletContextName = null;
3301                                            _pluginStringArray = null;
3302                                    }
3303                            }
3304                    }
3305    
3306                    private String[] _pluginStringArray;
3307                    private String[] _portalStringArray;
3308                    private String _servletContextName;
3309    
3310            }
3311    
3312            private class SanitizerContainer {
3313    
3314                    public void registerSanitizer(Sanitizer sanitizer) {
3315                            _sanitizers.add(sanitizer);
3316    
3317                            SanitizerImpl sanitizerImpl =
3318                                    (SanitizerImpl)SanitizerUtil.getSanitizer();
3319    
3320                            sanitizerImpl.registerSanitizer(sanitizer);
3321                    }
3322    
3323                    public void unregisterSanitizers() {
3324                            SanitizerImpl sanitizerImpl =
3325                                    (SanitizerImpl)SanitizerUtil.getSanitizer();
3326    
3327                            for (Sanitizer sanitizer : _sanitizers) {
3328                                    sanitizerImpl.unregisterSanitizer(sanitizer);
3329                            }
3330                    }
3331    
3332                    private List<Sanitizer> _sanitizers = new ArrayList<Sanitizer>();
3333    
3334            }
3335    
3336            private class ServiceBag {
3337    
3338                    public ServiceBag(Object originalService) {
3339                            _originalService = originalService;
3340                    }
3341    
3342                    public void addCustomServiceConstructor(
3343                            String servletContextName, ClassLoader portletClassLoader,
3344                            Class<?> serviceTypeClass, Constructor<?> serviceImplConstructor) {
3345    
3346                            List<ServiceConstructor> serviceConstructors =
3347                                    _serviceConstructors.get(servletContextName);
3348    
3349                            if (serviceConstructors == null) {
3350                                    serviceConstructors = new ArrayList<ServiceConstructor>();
3351    
3352                                    _serviceConstructors.put(
3353                                            servletContextName, serviceConstructors);
3354                            }
3355    
3356                            ServiceConstructor serviceConstructor = new ServiceConstructor(
3357                                    portletClassLoader, serviceTypeClass, serviceImplConstructor);
3358    
3359                            serviceConstructors.add(serviceConstructor);
3360                    }
3361    
3362                    public Object getCustomService() throws Exception {
3363                            List<ServiceConstructor> serviceConstructors =
3364                                    new ArrayList<ServiceConstructor>();
3365    
3366                            for (Map.Entry<String, List<ServiceConstructor>> entry :
3367                                            _serviceConstructors.entrySet()) {
3368    
3369                                    serviceConstructors.addAll(entry.getValue());
3370                            }
3371    
3372                            Object customService = _originalService;
3373    
3374                            for (ServiceConstructor serviceConstructor : serviceConstructors) {
3375                                    ClassLoader portletClassLoader =
3376                                            serviceConstructor._portletClassLoader;
3377                                    Class<?> serviceTypeClass =
3378                                            serviceConstructor._serviceTypeClass;
3379                                    Constructor<?> serviceImplConstructor =
3380                                            serviceConstructor._serviceImplConstructor;
3381    
3382                                    customService = serviceImplConstructor.newInstance(
3383                                            customService);
3384    
3385                                    customService = ProxyUtil.newProxyInstance(
3386                                            portletClassLoader, new Class<?>[] {serviceTypeClass},
3387                                            new ClassLoaderBeanHandler(
3388                                                    customService, portletClassLoader));
3389                            }
3390    
3391                            return customService;
3392                    }
3393    
3394                    private Object _originalService;
3395                    private Map<String, List<ServiceConstructor>> _serviceConstructors =
3396                            new HashMap<String, List<ServiceConstructor>>();
3397    
3398            }
3399    
3400            private class ServiceConstructor {
3401    
3402                    public ServiceConstructor(
3403                            ClassLoader portletClassLoader, Class<?> serviceTypeClass,
3404                            Constructor<?> serviceImplConstructor) {
3405    
3406                            _portletClassLoader = portletClassLoader;
3407                            _serviceTypeClass = serviceTypeClass;
3408                            _serviceImplConstructor = serviceImplConstructor;
3409                    }
3410    
3411                    private ClassLoader _portletClassLoader;
3412                    private Constructor<?> _serviceImplConstructor;
3413                    private Class<?> _serviceTypeClass;
3414    
3415            }
3416    
3417            private class ServicesContainer {
3418    
3419                    public void addServiceBag(
3420                            String servletContextName, ClassLoader portletClassLoader,
3421                            String serviceType, Class<?> serviceTypeClass,
3422                            Constructor<?> serviceImplConstructor, Object wrappedService) {
3423    
3424                            ServiceBag serviceBag = _serviceBags.get(serviceType);
3425    
3426                            if (serviceBag == null) {
3427                                    serviceBag = new ServiceBag(wrappedService);
3428    
3429                                    _serviceBags.put(serviceType, serviceBag);
3430                            }
3431    
3432                            serviceBag.addCustomServiceConstructor(
3433                                    servletContextName, portletClassLoader, serviceTypeClass,
3434                                    serviceImplConstructor);
3435                    }
3436    
3437                    private Map<String, ServiceBag> _serviceBags =
3438                            new HashMap<String, ServiceBag>();
3439    
3440            }
3441    
3442            private class ServletFiltersContainer {
3443    
3444                    public InvokerFilterHelper getInvokerFilterHelper() {
3445                            ServletContext portalServletContext = ServletContextPool.get(
3446                                    PortalUtil.getPathContext());
3447    
3448                            InvokerFilterHelper invokerFilterHelper =
3449                                    (InvokerFilterHelper)portalServletContext.getAttribute(
3450                                            InvokerFilterHelper.class.getName());
3451    
3452                            return invokerFilterHelper;
3453                    }
3454    
3455                    public void registerFilter(
3456                            String filterName, Filter filter, FilterConfig filterConfig) {
3457    
3458                            InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3459    
3460                            Filter previousFilter = invokerFilterHelper.registerFilter(
3461                                    filterName, filter);
3462    
3463                            _filterConfigs.put(filterName, filterConfig);
3464                            _filters.put(filterName, previousFilter);
3465                    }
3466    
3467                    public void registerFilterMapping(
3468                            String filterName, List<String> urlPatterns,
3469                            List<String> dispatchers, String positionFilterName,
3470                            boolean after) {
3471    
3472                            InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3473    
3474                            Filter filter = invokerFilterHelper.getFilter(filterName);
3475    
3476                            FilterConfig filterConfig = _filterConfigs.get(filterName);
3477    
3478                            if (filterConfig == null) {
3479                                    filterConfig = invokerFilterHelper.getFilterConfig(filterName);
3480                            }
3481    
3482                            if (filter == null) {
3483                                    if (_log.isWarnEnabled()) {
3484                                            _log.warn(
3485                                                    "No filter exists with filter mapping " + filterName);
3486                                    }
3487    
3488                                    return;
3489                            }
3490    
3491                            FilterMapping filterMapping = new FilterMapping(
3492                                    filter, filterConfig, urlPatterns, dispatchers);
3493    
3494                            invokerFilterHelper.registerFilterMapping(
3495                                    filterMapping, positionFilterName, after);
3496                    }
3497    
3498                    public void unregisterFilterMappings() {
3499                            InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3500    
3501                            for (String filterName : _filters.keySet()) {
3502                                    Filter filter = _filters.get(filterName);
3503    
3504                                    Filter previousFilter = invokerFilterHelper.registerFilter(
3505                                            filterName, filter);
3506    
3507                                    previousFilter.destroy();
3508                            }
3509    
3510                            for (FilterMapping filterMapping : _filterMappings) {
3511                                    invokerFilterHelper.unregisterFilterMapping(filterMapping);
3512    
3513                                    filterMapping.setFilter(null);
3514                            }
3515                    }
3516    
3517                    private Map<String, FilterConfig> _filterConfigs =
3518                            new HashMap<String, FilterConfig>();
3519                    private List<FilterMapping> _filterMappings =
3520                            new ArrayList<FilterMapping>();
3521                    private Map<String, Filter> _filters = new HashMap<String, Filter>();
3522    
3523            }
3524    
3525            private interface StringArraysContainer {
3526    
3527                    public String[] getStringArray();
3528    
3529                    public void setPluginStringArray(
3530                            String servletContextName, String[] pluginStringArray);
3531    
3532            }
3533    
3534            private class StrutsActionsContainer {
3535    
3536                    public void registerStrutsAction(String path, Object strutsAction) {
3537                            if (strutsAction instanceof StrutsAction) {
3538                                    StrutsActionRegistryUtil.register(
3539                                            path, (StrutsAction)strutsAction);
3540                            }
3541                            else {
3542                                    StrutsActionRegistryUtil.register(
3543                                            path, (StrutsPortletAction)strutsAction);
3544                            }
3545    
3546                            _paths.add(path);
3547                    }
3548    
3549                    public void unregisterStrutsActions() {
3550                            for (String path : _paths) {
3551                                    StrutsActionRegistryUtil.unregister(path);
3552                            }
3553    
3554                            _paths.clear();
3555                    }
3556    
3557                    private List<String> _paths = new ArrayList<String>();
3558    
3559            }
3560    
3561    }