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