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