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