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