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