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