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