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