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