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