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