001    /**
002     * Copyright (c) 2000-present 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.document.library.kernel.antivirus.AntivirusScanner;
018    import com.liferay.document.library.kernel.antivirus.AntivirusScannerUtil;
019    import com.liferay.document.library.kernel.antivirus.AntivirusScannerWrapper;
020    import com.liferay.document.library.kernel.util.DLProcessor;
021    import com.liferay.document.library.kernel.util.DLProcessorRegistryUtil;
022    import com.liferay.portal.captcha.CaptchaImpl;
023    import com.liferay.portal.kernel.bean.BeanLocatorException;
024    import com.liferay.portal.kernel.bean.ClassLoaderBeanHandler;
025    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
026    import com.liferay.portal.kernel.bean.PortletBeanLocatorUtil;
027    import com.liferay.portal.kernel.captcha.Captcha;
028    import com.liferay.portal.kernel.captcha.CaptchaUtil;
029    import com.liferay.portal.kernel.configuration.Configuration;
030    import com.liferay.portal.kernel.configuration.ConfigurationFactoryUtil;
031    import com.liferay.portal.kernel.deploy.DeployManagerUtil;
032    import com.liferay.portal.kernel.deploy.auto.AutoDeployListener;
033    import com.liferay.portal.kernel.deploy.hot.BaseHotDeployListener;
034    import com.liferay.portal.kernel.deploy.hot.HotDeployEvent;
035    import com.liferay.portal.kernel.deploy.hot.HotDeployException;
036    import com.liferay.portal.kernel.deploy.hot.HotDeployListener;
037    import com.liferay.portal.kernel.deploy.hot.HotDeployUtil;
038    import com.liferay.portal.kernel.events.Action;
039    import com.liferay.portal.kernel.events.InvokerAction;
040    import com.liferay.portal.kernel.events.InvokerSessionAction;
041    import com.liferay.portal.kernel.events.InvokerSimpleAction;
042    import com.liferay.portal.kernel.events.LifecycleAction;
043    import com.liferay.portal.kernel.events.SessionAction;
044    import com.liferay.portal.kernel.events.SimpleAction;
045    import com.liferay.portal.kernel.format.PhoneNumberFormat;
046    import com.liferay.portal.kernel.language.LanguageUtil;
047    import com.liferay.portal.kernel.lock.LockListener;
048    import com.liferay.portal.kernel.log.Log;
049    import com.liferay.portal.kernel.log.LogFactoryUtil;
050    import com.liferay.portal.kernel.model.ModelListener;
051    import com.liferay.portal.kernel.plugin.PluginPackage;
052    import com.liferay.portal.kernel.portlet.ControlPanelEntry;
053    import com.liferay.portal.kernel.sanitizer.Sanitizer;
054    import com.liferay.portal.kernel.search.IndexerPostProcessor;
055    import com.liferay.portal.kernel.security.auth.AuthFailure;
056    import com.liferay.portal.kernel.security.auth.AuthToken;
057    import com.liferay.portal.kernel.security.auth.Authenticator;
058    import com.liferay.portal.kernel.security.auth.CompanyThreadLocal;
059    import com.liferay.portal.kernel.security.auth.EmailAddressGenerator;
060    import com.liferay.portal.kernel.security.auth.EmailAddressValidator;
061    import com.liferay.portal.kernel.security.auth.FullNameGenerator;
062    import com.liferay.portal.kernel.security.auth.FullNameValidator;
063    import com.liferay.portal.kernel.security.auth.InterruptedPortletRequestWhitelistUtil;
064    import com.liferay.portal.kernel.security.auth.ScreenNameGenerator;
065    import com.liferay.portal.kernel.security.auth.ScreenNameValidator;
066    import com.liferay.portal.kernel.security.auth.verifier.AuthVerifier;
067    import com.liferay.portal.kernel.security.auto.login.AutoLogin;
068    import com.liferay.portal.kernel.security.ldap.AttributesTransformer;
069    import com.liferay.portal.kernel.security.membershippolicy.OrganizationMembershipPolicy;
070    import com.liferay.portal.kernel.security.membershippolicy.RoleMembershipPolicy;
071    import com.liferay.portal.kernel.security.membershippolicy.SiteMembershipPolicy;
072    import com.liferay.portal.kernel.security.membershippolicy.UserGroupMembershipPolicy;
073    import com.liferay.portal.kernel.security.pacl.PACLConstants;
074    import com.liferay.portal.kernel.security.pacl.permission.PortalHookPermission;
075    import com.liferay.portal.kernel.security.pwd.Toolkit;
076    import com.liferay.portal.kernel.service.ReleaseLocalServiceUtil;
077    import com.liferay.portal.kernel.service.ServiceWrapper;
078    import com.liferay.portal.kernel.service.persistence.BasePersistence;
079    import com.liferay.portal.kernel.servlet.DirectServletRegistryUtil;
080    import com.liferay.portal.kernel.servlet.LiferayFilter;
081    import com.liferay.portal.kernel.servlet.LiferayFilterTracker;
082    import com.liferay.portal.kernel.servlet.TryFilter;
083    import com.liferay.portal.kernel.servlet.TryFinallyFilter;
084    import com.liferay.portal.kernel.servlet.WrapHttpServletRequestFilter;
085    import com.liferay.portal.kernel.servlet.WrapHttpServletResponseFilter;
086    import com.liferay.portal.kernel.servlet.taglib.ui.FormNavigatorConstants;
087    import com.liferay.portal.kernel.servlet.taglib.ui.FormNavigatorEntry;
088    import com.liferay.portal.kernel.struts.StrutsAction;
089    import com.liferay.portal.kernel.struts.StrutsPortletAction;
090    import com.liferay.portal.kernel.upgrade.UpgradeProcess;
091    import com.liferay.portal.kernel.upgrade.util.UpgradeProcessUtil;
092    import com.liferay.portal.kernel.url.ServletContextURLContainer;
093    import com.liferay.portal.kernel.util.CharPool;
094    import com.liferay.portal.kernel.util.GetterUtil;
095    import com.liferay.portal.kernel.util.HttpUtil;
096    import com.liferay.portal.kernel.util.InstanceFactory;
097    import com.liferay.portal.kernel.util.LocaleUtil;
098    import com.liferay.portal.kernel.util.PropertiesUtil;
099    import com.liferay.portal.kernel.util.PropsKeys;
100    import com.liferay.portal.kernel.util.ProxyUtil;
101    import com.liferay.portal.kernel.util.ReflectionUtil;
102    import com.liferay.portal.kernel.util.SetUtil;
103    import com.liferay.portal.kernel.util.StringPool;
104    import com.liferay.portal.kernel.util.StringUtil;
105    import com.liferay.portal.kernel.util.Tuple;
106    import com.liferay.portal.kernel.util.Validator;
107    import com.liferay.portal.kernel.xml.Document;
108    import com.liferay.portal.kernel.xml.Element;
109    import com.liferay.portal.kernel.xml.UnsecureSAXReaderUtil;
110    import com.liferay.portal.language.LiferayResourceBundle;
111    import com.liferay.portal.repository.registry.RepositoryClassDefinitionCatalogUtil;
112    import com.liferay.portal.repository.util.ExternalRepositoryFactory;
113    import com.liferay.portal.repository.util.ExternalRepositoryFactoryImpl;
114    import com.liferay.portal.security.auth.AuthVerifierPipeline;
115    import com.liferay.portal.security.lang.DoPrivilegedBean;
116    import com.liferay.portal.servlet.filters.cache.CacheUtil;
117    import com.liferay.portal.servlet.taglib.ui.DeprecatedFormNavigatorEntry;
118    import com.liferay.portal.spring.aop.ServiceBeanAopProxy;
119    import com.liferay.portal.spring.context.PortalContextLoaderListener;
120    import com.liferay.portal.util.JavaScriptBundleUtil;
121    import com.liferay.portal.util.PortalInstances;
122    import com.liferay.portal.util.PropsUtil;
123    import com.liferay.portal.util.PropsValues;
124    import com.liferay.portlet.documentlibrary.store.StoreFactory;
125    import com.liferay.registry.Registry;
126    import com.liferay.registry.RegistryUtil;
127    import com.liferay.registry.ServiceRegistration;
128    import com.liferay.taglib.FileAvailabilityUtil;
129    
130    import java.io.InputStream;
131    
132    import java.lang.reflect.Constructor;
133    import java.lang.reflect.Field;
134    
135    import java.net.URL;
136    
137    import java.util.ArrayList;
138    import java.util.Arrays;
139    import java.util.HashMap;
140    import java.util.HashSet;
141    import java.util.Iterator;
142    import java.util.LinkedHashSet;
143    import java.util.List;
144    import java.util.Locale;
145    import java.util.Map;
146    import java.util.Properties;
147    import java.util.ResourceBundle;
148    import java.util.Set;
149    import java.util.concurrent.ConcurrentHashMap;
150    
151    import javax.servlet.Filter;
152    import javax.servlet.ServletContext;
153    
154    import org.springframework.aop.TargetSource;
155    import org.springframework.aop.framework.AdvisedSupport;
156    
157    /**
158     * @author Brian Wing Shun Chan
159     * @author Bruno Farache
160     * @author Wesley Gong
161     * @author Ryan Park
162     * @author Mika Koivisto
163     * @author Peter Fellwock
164     * @author Raymond Augé
165     * @author Kamesh Sampath
166     */
167    public class HookHotDeployListener
168            extends BaseHotDeployListener implements PropsKeys {
169    
170            public static final String[] SUPPORTED_PROPERTIES = {
171                    "admin.default.group.names", "admin.default.role.names",
172                    "admin.default.user.group.names",
173                    "asset.publisher.asset.entry.query.processors",
174                    "asset.publisher.display.styles", "auth.forward.by.last.path",
175                    "auth.public.paths", "auth.verifier.pipeline", "auto.deploy.listeners",
176                    "application.startup.events", "auth.failure", "auth.max.failures",
177                    "auth.token.ignore.actions", "auth.token.ignore.origins",
178                    "auth.token.ignore.portlets", "auth.token.impl", "auth.pipeline.post",
179                    "auth.pipeline.pre", "auto.login.hooks",
180                    "captcha.check.portal.create_account", "captcha.engine.impl",
181                    "company.default.locale", "company.default.time.zone",
182                    "company.settings.form.authentication",
183                    "company.settings.form.configuration",
184                    "company.settings.form.identification",
185                    "company.settings.form.miscellaneous", "company.settings.form.social",
186                    "control.panel.entry.class.default", "default.landing.page.path",
187                    "default.regular.color.scheme.id", "default.regular.theme.id",
188                    "dl.file.entry.drafts.enabled",
189                    "dl.file.entry.open.in.ms.office.manual.check.in.required",
190                    "dl.file.entry.processors", "dl.repository.impl",
191                    "dl.store.antivirus.impl", "dl.store.impl", "dockbar.add.portlets",
192                    "field.enable.com.liferay.portal.kernel.model.Contact.birthday",
193                    "field.enable.com.liferay.portal.kernel.model.Contact.male",
194                    "field.enable.com.liferay.portal.kernel.model.Organization.status",
195                    "hot.deploy.listeners", "javascript.fast.load",
196                    "journal.article.form.add", "journal.article.form.translate",
197                    "journal.article.form.update", "layout.form.add", "layout.form.update",
198                    "layout.set.form.update", "layout.static.portlets.all",
199                    "layout.template.cache.enabled", "layout.types",
200                    "layout.user.private.layouts.auto.create",
201                    "layout.user.private.layouts.enabled",
202                    "layout.user.private.layouts.power.user.required",
203                    "layout.user.public.layouts.auto.create",
204                    "layout.user.public.layouts.enabled",
205                    "layout.user.public.layouts.power.user.required",
206                    "ldap.attrs.transformer.impl", "locales", "locales.beta",
207                    "locales.enabled", "lock.listeners",
208                    "login.create.account.allow.custom.password", "login.dialog.disabled",
209                    "login.events.post", "login.events.pre", "login.form.navigation.post",
210                    "login.form.navigation.pre", "logout.events.post", "logout.events.pre",
211                    "mail.hook.impl", "my.sites.show.private.sites.with.no.layouts",
212                    "my.sites.show.public.sites.with.no.layouts",
213                    "my.sites.show.user.private.sites.with.no.layouts",
214                    "my.sites.show.user.public.sites.with.no.layouts",
215                    "organizations.form.add.identification", "organizations.form.add.main",
216                    "organizations.form.add.miscellaneous",
217                    "passwords.passwordpolicytoolkit.generator",
218                    "passwords.passwordpolicytoolkit.static", "phone.number.format.impl",
219                    "phone.number.format.international.regexp",
220                    "phone.number.format.usa.regexp",
221                    "portlet.add.default.resource.check.enabled",
222                    "portlet.add.default.resource.check.whitelist",
223                    "portlet.add.default.resource.check.whitelist.actions",
224                    "rss.feeds.enabled", "sanitizer.impl", "servlet.session.create.events",
225                    "servlet.session.destroy.events", "servlet.service.events.post",
226                    "servlet.service.events.pre", "session.max.allowed",
227                    "session.phishing.protected.attributes", "session.store.password",
228                    "sites.form.add.advanced", "sites.form.add.main",
229                    "sites.form.add.miscellaneous", "sites.form.add.seo",
230                    "sites.form.update.advanced", "sites.form.update.main",
231                    "sites.form.update.miscellaneous", "sites.form.update.seo",
232                    "social.activity.sets.bundling.enabled", "social.activity.sets.enabled",
233                    "social.activity.sets.selector", "social.bookmark.*",
234                    "terms.of.use.required", "theme.css.fast.load",
235                    "theme.images.fast.load", "theme.jsp.override.enabled",
236                    "theme.loader.new.theme.id.on.import", "theme.portlet.decorate.default",
237                    "theme.portlet.sharing.default", "theme.shortcut.icon", "time.zones",
238                    "upgrade.processes", "user.notification.event.confirmation.enabled",
239                    "users.email.address.generator", "users.email.address.validator",
240                    "users.email.address.required", "users.form.add.identification",
241                    "users.form.add.main", "users.form.add.miscellaneous",
242                    "users.form.my.account.identification", "users.form.my.account.main",
243                    "users.form.my.account.miscellaneous",
244                    "users.form.update.identification", "users.form.update.main",
245                    "users.form.update.miscellaneous", "users.full.name.generator",
246                    "users.full.name.validator", "users.image.check.token",
247                    "users.image.max.height", "users.image.max.width",
248                    "users.screen.name.always.autogenerate", "users.screen.name.generator",
249                    "users.screen.name.validator", "value.object.listener.*"
250            };
251    
252            public HookHotDeployListener() {
253                    for (String key : _PROPS_VALUES_MERGE_STRING_ARRAY) {
254                            _mergeStringArraysContainerMap.put(
255                                    key, new MergeStringArraysContainer(key));
256                    }
257    
258                    for (String key : _PROPS_VALUES_OVERRIDE_STRING_ARRAY) {
259                            _overrideStringArraysContainerMap.put(
260                                    key, new OverrideStringArraysContainer(key));
261                    }
262            }
263    
264            @Override
265            public void invokeDeploy(HotDeployEvent hotDeployEvent)
266                    throws HotDeployException {
267    
268                    try {
269                            doInvokeDeploy(hotDeployEvent);
270                    }
271                    catch (Throwable t) {
272                            throwHotDeployException(
273                                    hotDeployEvent, "Error registering hook for ", t);
274                    }
275            }
276    
277            @Override
278            public void invokeUndeploy(HotDeployEvent hotDeployEvent)
279                    throws HotDeployException {
280    
281                    try {
282                            doInvokeUndeploy(hotDeployEvent);
283                    }
284                    catch (Throwable t) {
285                            throwHotDeployException(
286                                    hotDeployEvent, "Error unregistering hook for ", t);
287                    }
288            }
289    
290            public <T> void registerService(
291                    String servletContextName, Object serviceRegistrationKey,
292                    Class<T> clazz, T service, Map<String, Object> properties) {
293    
294                    Map<Object, ServiceRegistration<?>> serviceRegistrations =
295                            getServiceRegistrations(servletContextName);
296    
297                    Registry registry = RegistryUtil.getRegistry();
298    
299                    ServiceRegistration<T> serviceRegistration = registry.registerService(
300                            clazz, service, properties);
301    
302                    serviceRegistrations.put(serviceRegistrationKey, serviceRegistration);
303            }
304    
305            public <T> void registerService(
306                    String servletContextName, Object serviceRegistrationKey,
307                    Class<T> clazz, T service, Object... propertyKVPs) {
308    
309                    if ((propertyKVPs.length % 2) != 0) {
310                            throw new IllegalArgumentException(
311                                    "Properties length is not an even number");
312                    }
313    
314                    Map<String, Object> properties = new HashMap<>();
315    
316                    for (int i = 0; i < propertyKVPs.length; i += 2) {
317                            String propertyName = String.valueOf(propertyKVPs[i]);
318                            Object propertyValue = propertyKVPs[i + 1];
319    
320                            properties.put(propertyName, propertyValue);
321                    }
322    
323                    registerService(
324                            servletContextName, serviceRegistrationKey, clazz, service,
325                            properties);
326            }
327    
328            public <T> void registerService(
329                    String servletContextName, Object serviceRegistrationKey,
330                    Class<T> clazz, T service, Properties properties) {
331    
332                    registerService(
333                            servletContextName, serviceRegistrationKey, clazz, service,
334                            PropertiesUtil.toMap(properties));
335            }
336    
337            protected boolean checkPermission(
338                    String name, ClassLoader portletClassLoader, Object subject,
339                    String message) {
340    
341                    try {
342                            PortalHookPermission.checkPermission(
343                                    name, portletClassLoader, subject);
344                    }
345                    catch (SecurityException se) {
346                            if (_log.isInfoEnabled()) {
347                                    _log.info(message);
348                            }
349    
350                            return false;
351                    }
352    
353                    return true;
354            }
355    
356            protected boolean containsKey(Properties portalProperties, String key) {
357                    if (_log.isDebugEnabled()) {
358                            return true;
359                    }
360                    else {
361                            return portalProperties.containsKey(key);
362                    }
363            }
364    
365            protected void destroyCustomJspBag(
366                            String servletContextName, CustomJspBag customJspBag)
367                    throws Exception {
368            }
369    
370            protected void destroyPortalProperties(
371                            String servletContextName, Properties portalProperties)
372                    throws Exception {
373    
374                    PropsUtil.removeProperties(portalProperties);
375    
376                    if (_log.isDebugEnabled() && portalProperties.containsKey(LOCALES)) {
377                            _log.debug(
378                                    "Portlet locales " + portalProperties.getProperty(LOCALES));
379                            _log.debug("Original locales " + PropsUtil.get(LOCALES));
380                            _log.debug(
381                                    "Original locales array length " +
382                                            PropsUtil.getArray(LOCALES).length);
383                    }
384    
385                    resetPortalProperties(servletContextName, portalProperties, false);
386    
387                    if (portalProperties.containsKey(PropsKeys.CAPTCHA_ENGINE_IMPL)) {
388                            CaptchaImpl captchaImpl = null;
389    
390                            Captcha captcha = CaptchaUtil.getCaptcha();
391    
392                            if (captcha instanceof DoPrivilegedBean) {
393                                    DoPrivilegedBean doPrivilegedBean = (DoPrivilegedBean)captcha;
394    
395                                    captchaImpl = (CaptchaImpl)doPrivilegedBean.getActualBean();
396                            }
397                            else {
398                                    captchaImpl = (CaptchaImpl)captcha;
399                            }
400    
401                            captchaImpl.setCaptcha(null);
402                    }
403    
404                    if (portalProperties.containsKey(PropsKeys.DL_FILE_ENTRY_PROCESSORS)) {
405                            DLFileEntryProcessorContainer dlFileEntryProcessorContainer =
406                                    _dlFileEntryProcessorContainerMap.remove(servletContextName);
407    
408                            dlFileEntryProcessorContainer.unregisterDLProcessors();
409                    }
410    
411                    if (portalProperties.containsKey(PropsKeys.DL_REPOSITORY_IMPL)) {
412                            DLRepositoryContainer dlRepositoryContainer =
413                                    _dlRepositoryContainerMap.remove(servletContextName);
414    
415                            dlRepositoryContainer.unregisterRepositoryFactories();
416                    }
417    
418                    if (portalProperties.containsKey(PropsKeys.DL_STORE_ANTIVIRUS_IMPL)) {
419                            AntivirusScannerWrapper antivirusScannerWrapper =
420                                    (AntivirusScannerWrapper)
421                                            AntivirusScannerUtil.getAntivirusScanner();
422    
423                            antivirusScannerWrapper.setAntivirusScanner(null);
424                    }
425    
426                    if (portalProperties.containsKey(PropsKeys.DL_STORE_IMPL)) {
427                            StoreFactory storeFactory = StoreFactory.getInstance();
428    
429                            storeFactory.setStore(null);
430                    }
431    
432                    Set<String> liferayFilterClassNames =
433                            LiferayFilterTracker.getClassNames();
434    
435                    for (String liferayFilterClassName : liferayFilterClassNames) {
436                            if (!portalProperties.containsKey(liferayFilterClassName)) {
437                                    continue;
438                            }
439    
440                            boolean filterEnabled = GetterUtil.getBoolean(
441                                    PropsUtil.get(liferayFilterClassName));
442    
443                            Set<LiferayFilter> liferayFilters =
444                                    LiferayFilterTracker.getLiferayFilters(liferayFilterClassName);
445    
446                            for (LiferayFilter liferayFilter : liferayFilters) {
447                                    liferayFilter.setFilterEnabled(filterEnabled);
448                            }
449                    }
450            }
451    
452            protected void doInvokeDeploy(HotDeployEvent hotDeployEvent)
453                    throws Exception {
454    
455                    ServletContext servletContext = hotDeployEvent.getServletContext();
456    
457                    String servletContextName = servletContext.getServletContextName();
458    
459                    if (_log.isDebugEnabled()) {
460                            _log.debug("Invoking deploy for " + servletContextName);
461                    }
462    
463                    String xml = HttpUtil.URLtoString(
464                            servletContext.getResource("/WEB-INF/liferay-hook.xml"));
465    
466                    if (xml == null) {
467                            return;
468                    }
469    
470                    if (_log.isInfoEnabled()) {
471                            _log.info("Registering hook for " + servletContextName);
472                    }
473    
474                    _servletContextNames.add(servletContextName);
475    
476                    Document document = UnsecureSAXReaderUtil.read(xml, true);
477    
478                    Element rootElement = document.getRootElement();
479    
480                    ClassLoader portletClassLoader = hotDeployEvent.getContextClassLoader();
481    
482                    initPortalProperties(
483                            servletContextName, portletClassLoader, rootElement);
484    
485                    initLanguageProperties(
486                            servletContextName, portletClassLoader, rootElement);
487    
488                    try {
489                            initCustomJspDir(
490                                    servletContext, servletContextName, portletClassLoader,
491                                    hotDeployEvent.getPluginPackage(), rootElement);
492                    }
493                    catch (DuplicateCustomJspException dcje) {
494                            if (_log.isWarnEnabled()) {
495                                    _log.warn(servletContextName + " will be undeployed");
496                            }
497    
498                            HotDeployUtil.fireUndeployEvent(
499                                    new HotDeployEvent(servletContext, portletClassLoader));
500    
501                            DeployManagerUtil.undeploy(servletContextName);
502    
503                            return;
504                    }
505    
506                    initIndexerPostProcessors(
507                            servletContextName, portletClassLoader, rootElement);
508    
509                    initServices(servletContextName, portletClassLoader, rootElement);
510    
511                    initServletFilters(
512                            servletContext, servletContextName, portletClassLoader,
513                            rootElement);
514    
515                    initStrutsActions(servletContextName, portletClassLoader, rootElement);
516    
517                    List<Element> modelListenerElements = rootElement.elements(
518                            "model-listener");
519    
520                    for (Element modelListenerElement : modelListenerElements) {
521                            String modelName = modelListenerElement.elementText("model-name");
522                            String modelListenerClassName = modelListenerElement.elementText(
523                                    "model-listener-class");
524    
525                            initModelListener(
526                                    servletContextName, portletClassLoader, modelName,
527                                    modelListenerClassName);
528                    }
529    
530                    List<Element> eventElements = rootElement.elements("event");
531    
532                    for (Element eventElement : eventElements) {
533                            String eventName = eventElement.elementText("event-type");
534                            String eventClassName = eventElement.elementText("event-class");
535    
536                            initEvent(
537                                    servletContextName, portletClassLoader, eventName,
538                                    eventClassName);
539                    }
540    
541                    // End backwards compatibility for 5.1.0
542    
543                    registerClpMessageListeners(servletContext, portletClassLoader);
544    
545                    DirectServletRegistryUtil.clearServlets();
546                    FileAvailabilityUtil.clearAvailabilities();
547    
548                    if (_log.isInfoEnabled()) {
549                            _log.info(
550                                    "Hook for " + servletContextName + " is available for use");
551                    }
552            }
553    
554            protected void doInvokeUndeploy(HotDeployEvent hotDeployEvent)
555                    throws Exception {
556    
557                    ServletContext servletContext = hotDeployEvent.getServletContext();
558    
559                    String servletContextName = servletContext.getServletContextName();
560    
561                    if (_log.isDebugEnabled()) {
562                            _log.debug("Invoking undeploy for " + servletContextName);
563                    }
564    
565                    if (!_servletContextNames.remove(servletContextName)) {
566                            return;
567                    }
568    
569                    HotDeployListenersContainer hotDeployListenersContainer =
570                            _hotDeployListenersContainerMap.remove(servletContextName);
571    
572                    if (hotDeployListenersContainer != null) {
573                            hotDeployListenersContainer.unregisterHotDeployListeners();
574                    }
575    
576                    Properties portalProperties = _portalPropertiesMap.remove(
577                            servletContextName);
578    
579                    if (portalProperties != null) {
580                            destroyPortalProperties(servletContextName, portalProperties);
581                    }
582    
583                    unregisterClpMessageListeners(servletContext);
584    
585                    Map<Object, ServiceRegistration<?>> serviceRegistrations =
586                            _serviceRegistrations.remove(servletContextName);
587    
588                    if (serviceRegistrations != null) {
589                            for (ServiceRegistration<?> serviceRegistration :
590                                            serviceRegistrations.values()) {
591    
592                                    serviceRegistration.unregister();
593                            }
594    
595                            serviceRegistrations.clear();
596                    }
597    
598                    if (_log.isInfoEnabled()) {
599                            _log.info("Hook for " + servletContextName + " was unregistered");
600                    }
601            }
602    
603            protected Locale getLocale(String languagePropertiesLocation) {
604                    int x = languagePropertiesLocation.indexOf(CharPool.UNDERLINE);
605                    int y = languagePropertiesLocation.indexOf(".properties");
606    
607                    Locale locale = null;
608    
609                    if ((x != -1) && (y != 1)) {
610                            String localeKey = languagePropertiesLocation.substring(x + 1, y);
611    
612                            locale = LocaleUtil.fromLanguageId(localeKey, true, false);
613                    }
614    
615                    return locale;
616            }
617    
618            protected BasePersistence<?> getPersistence(
619                    String servletContextName, String modelName) {
620    
621                    int pos = modelName.lastIndexOf(CharPool.PERIOD);
622    
623                    String entityName = modelName.substring(pos + 1);
624    
625                    pos = modelName.lastIndexOf(".model.");
626    
627                    String packagePath = modelName.substring(0, pos);
628    
629                    String beanName =
630                            packagePath + ".service.persistence." + entityName + "Persistence";
631    
632                    try {
633                            return (BasePersistence<?>)PortalBeanLocatorUtil.locate(beanName);
634                    }
635                    catch (BeanLocatorException ble) {
636                            return (BasePersistence<?>)PortletBeanLocatorUtil.locate(
637                                    servletContextName, beanName);
638                    }
639            }
640    
641            protected Map<Object, ServiceRegistration<?>> getServiceRegistrations(
642                    String servletContextName) {
643    
644                    Map<Object, ServiceRegistration<?>> serviceRegistrations =
645                            _serviceRegistrations.get(servletContextName);
646    
647                    if (serviceRegistrations == null) {
648                            serviceRegistrations = newMap();
649    
650                            _serviceRegistrations.put(servletContextName, serviceRegistrations);
651                    }
652    
653                    return serviceRegistrations;
654            }
655    
656            protected void initAuthenticators(
657                            String servletContextName, ClassLoader portletClassLoader,
658                            Properties portalProperties)
659                    throws Exception {
660    
661                    initAuthenticators(
662                            servletContextName, portletClassLoader, portalProperties,
663                            AUTH_PIPELINE_PRE);
664                    initAuthenticators(
665                            servletContextName, portletClassLoader, portalProperties,
666                            AUTH_PIPELINE_POST);
667            }
668    
669            protected void initAuthenticators(
670                            String servletContextName, ClassLoader portletClassLoader,
671                            Properties portalProperties, String key)
672                    throws Exception {
673    
674                    String[] authenticatorClassNames = StringUtil.split(
675                            portalProperties.getProperty(key));
676    
677                    for (String authenticatorClassName : authenticatorClassNames) {
678                            Authenticator authenticator = (Authenticator)newInstance(
679                                    portletClassLoader, Authenticator.class,
680                                    authenticatorClassName);
681    
682                            registerService(
683                                    servletContextName, authenticatorClassName, Authenticator.class,
684                                    authenticator, "key", key);
685                    }
686            }
687    
688            protected void initAuthFailures(
689                            String servletContextName, ClassLoader portletClassLoader,
690                            Properties portalProperties)
691                    throws Exception {
692    
693                    initAuthFailures(
694                            servletContextName, portletClassLoader, portalProperties,
695                            AUTH_FAILURE);
696                    initAuthFailures(
697                            servletContextName, portletClassLoader, portalProperties,
698                            AUTH_MAX_FAILURES);
699            }
700    
701            protected void initAuthFailures(
702                            String servletContextName, ClassLoader portletClassLoader,
703                            Properties portalProperties, String key)
704                    throws Exception {
705    
706                    String[] authFailureClassNames = StringUtil.split(
707                            portalProperties.getProperty(key));
708    
709                    for (String authFailureClassName : authFailureClassNames) {
710                            AuthFailure authFailure = (AuthFailure)newInstance(
711                                    portletClassLoader, AuthFailure.class, authFailureClassName);
712    
713                            registerService(
714                                    servletContextName, authFailureClassName, AuthFailure.class,
715                                    authFailure, "key", key);
716                    }
717            }
718    
719            protected void initAuthPublicPaths(
720                            String servletContextName, Properties portalProperties)
721                    throws Exception {
722    
723                    String[] authPublicPaths = StringUtil.split(
724                            portalProperties.getProperty(AUTH_PUBLIC_PATHS));
725    
726                    for (String authPublicPath : authPublicPaths) {
727                            registerService(
728                                    servletContextName, AUTH_PUBLIC_PATHS + authPublicPath,
729                                    Object.class, new Object(), "auth.public.path", authPublicPath);
730                    }
731            }
732    
733            protected void initAuthVerifiers(
734                            String servletContextName, ClassLoader portletClassLoader,
735                            Properties portalProperties)
736                    throws Exception {
737    
738                    String[] authVerifierClassNames = StringUtil.split(
739                            portalProperties.getProperty(AUTH_VERIFIER_PIPELINE));
740    
741                    for (String authVerifierClassName : authVerifierClassNames) {
742                            AuthVerifier authVerifier = (AuthVerifier)newInstance(
743                                    portletClassLoader, AuthVerifier.class, authVerifierClassName);
744    
745                            Properties properties = PropertiesUtil.getProperties(
746                                    portalProperties,
747                                    AuthVerifierPipeline.getAuthVerifierPropertyName(
748                                            authVerifierClassName),
749                                    true);
750    
751                            registerService(
752                                    servletContextName, authVerifierClassName, AuthVerifier.class,
753                                    authVerifier, properties);
754                    }
755            }
756    
757            protected void initAutoDeployListeners(
758                            String servletContextName, ClassLoader portletClassLoader,
759                            Properties portalProperties)
760                    throws Exception {
761    
762                    String[] autoDeployListenerClassNames = StringUtil.split(
763                            portalProperties.getProperty(PropsKeys.AUTO_DEPLOY_LISTENERS));
764    
765                    if (autoDeployListenerClassNames.length == 0) {
766                            return;
767                    }
768    
769                    for (String autoDeployListenerClassName :
770                                    autoDeployListenerClassNames) {
771    
772                            AutoDeployListener autoDeployListener =
773                                    (AutoDeployListener)newInstance(
774                                            portletClassLoader, AutoDeployListener.class,
775                                            autoDeployListenerClassName);
776    
777                            registerService(
778                                    servletContextName, autoDeployListenerClassName,
779                                    AutoDeployListener.class, autoDeployListener);
780                    }
781            }
782    
783            protected void initAutoLogins(
784                            String servletContextName, ClassLoader portletClassLoader,
785                            Properties portalProperties)
786                    throws Exception {
787    
788                    String[] autoLoginClassNames = StringUtil.split(
789                            portalProperties.getProperty(AUTO_LOGIN_HOOKS));
790    
791                    for (String autoLoginClassName : autoLoginClassNames) {
792                            AutoLogin autoLogin = (AutoLogin)newInstance(
793                                    portletClassLoader, AutoLogin.class, autoLoginClassName);
794    
795                            registerService(
796                                    servletContextName, autoLoginClassName, AutoLogin.class,
797                                    autoLogin);
798                    }
799            }
800    
801            protected void initCustomJspDir(
802                            ServletContext servletContext, String servletContextName,
803                            ClassLoader portletClassLoader, PluginPackage pluginPackage,
804                            Element rootElement)
805                    throws Exception {
806    
807                    String customJspDir = rootElement.elementText("custom-jsp-dir");
808    
809                    if (Validator.isNull(customJspDir)) {
810                            return;
811                    }
812    
813                    if (!checkPermission(
814                                    PACLConstants.PORTAL_HOOK_PERMISSION_CUSTOM_JSP_DIR,
815                                    portletClassLoader, null, "Rejecting custom JSP directory")) {
816    
817                            return;
818                    }
819    
820                    if (_log.isDebugEnabled()) {
821                            _log.debug("Custom JSP directory: " + customJspDir);
822                    }
823    
824                    boolean customJspGlobal = GetterUtil.getBoolean(
825                            rootElement.elementText("custom-jsp-global"), true);
826    
827                    CustomJspBag customJspBag = new CustomJspBagImpl(
828                            new ServletContextURLContainer(servletContext), customJspDir,
829                            customJspGlobal);
830    
831                    registerService(
832                            servletContextName, "customJsp", CustomJspBag.class, customJspBag,
833                            "context.id", servletContextName, "context.name",
834                            pluginPackage.getName());
835            }
836    
837            protected void initEvent(
838                            String servletContextName, ClassLoader portletClassLoader,
839                            String eventName, String eventClassName)
840                    throws Exception {
841    
842                    if (eventName.equals(APPLICATION_STARTUP_EVENTS)) {
843                            Class<?> clazz = portletClassLoader.loadClass(eventClassName);
844    
845                            SimpleAction simpleAction = (SimpleAction)clazz.newInstance();
846    
847                            simpleAction = new InvokerSimpleAction(
848                                    simpleAction, portletClassLoader);
849    
850                            Long companyId = CompanyThreadLocal.getCompanyId();
851    
852                            try {
853                                    long[] companyIds = PortalInstances.getCompanyIds();
854    
855                                    for (long curCompanyId : companyIds) {
856                                            CompanyThreadLocal.setCompanyId(curCompanyId);
857    
858                                            simpleAction.run(
859                                                    new String[] {String.valueOf(curCompanyId)});
860                                    }
861                            }
862                            finally {
863                                    CompanyThreadLocal.setCompanyId(companyId);
864                            }
865                    }
866    
867                    if (_propsKeysEvents.contains(eventName)) {
868                            Class<?> clazz = portletClassLoader.loadClass(eventClassName);
869    
870                            Action action = (Action)clazz.newInstance();
871    
872                            action = new InvokerAction(action, portletClassLoader);
873    
874                            registerService(
875                                    servletContextName, eventClassName, LifecycleAction.class,
876                                    action, "key", eventName);
877                    }
878    
879                    if (_propsKeysSessionEvents.contains(eventName)) {
880                            Class<?> clazz = portletClassLoader.loadClass(eventClassName);
881    
882                            SessionAction sessionAction = (SessionAction)clazz.newInstance();
883    
884                            sessionAction = new InvokerSessionAction(
885                                    sessionAction, portletClassLoader);
886    
887                            registerService(
888                                    servletContextName, eventClassName, LifecycleAction.class,
889                                    sessionAction, "key", eventName);
890                    }
891            }
892    
893            protected void initEvents(
894                            String servletContextName, ClassLoader portletClassLoader,
895                            Properties portalProperties)
896                    throws Exception {
897    
898                    for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
899                            String key = (String)entry.getKey();
900    
901                            if (!key.equals(APPLICATION_STARTUP_EVENTS) &&
902                                    !_propsKeysEvents.contains(key) &&
903                                    !_propsKeysSessionEvents.contains(key)) {
904    
905                                    continue;
906                            }
907    
908                            String eventName = key;
909                            String[] eventClassNames = StringUtil.split(
910                                    (String)entry.getValue());
911    
912                            for (String eventClassName : eventClassNames) {
913                                    initEvent(
914                                            servletContextName, portletClassLoader, eventName,
915                                            eventClassName);
916                            }
917                    }
918            }
919    
920            protected void initFormNavigatorEntries(
921                            String servletContextName, Properties portalProperties)
922                    throws Exception {
923    
924                    initFormNavigatorEntry(
925                            servletContextName, portalProperties,
926                            COMPANY_SETTINGS_FORM_CONFIGURATION,
927                            FormNavigatorConstants.CATEGORY_KEY_COMPANY_SETTINGS_CONFIGURATION,
928                            FormNavigatorConstants.FORM_NAVIGATOR_ID_COMPANY_SETTINGS,
929                            "portal_settings");
930                    initFormNavigatorEntry(
931                            servletContextName, portalProperties,
932                            COMPANY_SETTINGS_FORM_IDENTIFICATION,
933                            FormNavigatorConstants.CATEGORY_KEY_COMPANY_SETTINGS_IDENTIFICATION,
934                            FormNavigatorConstants.FORM_NAVIGATOR_ID_COMPANY_SETTINGS,
935                            "portal_settings");
936                    initFormNavigatorEntry(
937                            servletContextName, portalProperties,
938                            COMPANY_SETTINGS_FORM_MISCELLANEOUS,
939                            FormNavigatorConstants.CATEGORY_KEY_COMPANY_SETTINGS_MISCELLANEOUS,
940                            FormNavigatorConstants.FORM_NAVIGATOR_ID_COMPANY_SETTINGS,
941                            "portal_settings");
942                    initFormNavigatorEntry(
943                            servletContextName, portalProperties, COMPANY_SETTINGS_FORM_SOCIAL,
944                            FormNavigatorConstants.CATEGORY_KEY_COMPANY_SETTINGS_SOCIAL,
945                            FormNavigatorConstants.FORM_NAVIGATOR_ID_COMPANY_SETTINGS,
946                            "portal_settings");
947    
948                    initFormNavigatorEntry(
949                            servletContextName, portalProperties, LAYOUT_FORM_ADD,
950                            StringPool.BLANK, FormNavigatorConstants.FORM_NAVIGATOR_ID_LAYOUT,
951                            "layouts_admin/layout");
952                    initFormNavigatorEntry(
953                            servletContextName, portalProperties, LAYOUT_FORM_UPDATE,
954                            StringPool.BLANK, FormNavigatorConstants.FORM_NAVIGATOR_ID_LAYOUT,
955                            "layouts_admin/layout");
956    
957                    initFormNavigatorEntry(
958                            servletContextName, portalProperties, LAYOUT_SET_FORM_UPDATE,
959                            StringPool.BLANK,
960                            FormNavigatorConstants.FORM_NAVIGATOR_ID_LAYOUT_SET,
961                            "layouts_admin/layout_set");
962    
963                    initFormNavigatorEntry(
964                            servletContextName, portalProperties,
965                            ORGANIZATIONS_FORM_ADD_IDENTIFICATION,
966                            FormNavigatorConstants.CATEGORY_KEY_ORGANIZATION_IDENTIFICATION,
967                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
968                            "users_admin/organization");
969                    initFormNavigatorEntry(
970                            servletContextName, portalProperties, ORGANIZATIONS_FORM_ADD_MAIN,
971                            FormNavigatorConstants.
972                                    CATEGORY_KEY_ORGANIZATION_ORGANIZATION_INFORMATION,
973                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
974                            "users_admin/organization");
975                    initFormNavigatorEntry(
976                            servletContextName, portalProperties,
977                            ORGANIZATIONS_FORM_ADD_MISCELLANEOUS,
978                            FormNavigatorConstants.CATEGORY_KEY_ORGANIZATION_MISCELLANEOUS,
979                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
980                            "users_admin/organization");
981                    initFormNavigatorEntry(
982                            servletContextName, portalProperties,
983                            ORGANIZATIONS_FORM_UPDATE_IDENTIFICATION,
984                            FormNavigatorConstants.CATEGORY_KEY_ORGANIZATION_IDENTIFICATION,
985                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
986                            "users_admin/organization");
987                    initFormNavigatorEntry(
988                            servletContextName, portalProperties,
989                            ORGANIZATIONS_FORM_UPDATE_MAIN,
990                            FormNavigatorConstants.
991                                    CATEGORY_KEY_ORGANIZATION_ORGANIZATION_INFORMATION,
992                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
993                            "users_admin/organization");
994                    initFormNavigatorEntry(
995                            servletContextName, portalProperties,
996                            ORGANIZATIONS_FORM_UPDATE_MISCELLANEOUS,
997                            FormNavigatorConstants.CATEGORY_KEY_ORGANIZATION_MISCELLANEOUS,
998                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
999                            "users_admin/organization");
1000    
1001                    initFormNavigatorEntry(
1002                            servletContextName, portalProperties, SITES_FORM_ADD_ADVANCED,
1003                            FormNavigatorConstants.CATEGORY_KEY_SITES_ADVANCED,
1004                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1005                    initFormNavigatorEntry(
1006                            servletContextName, portalProperties, SITES_FORM_ADD_MAIN,
1007                            FormNavigatorConstants.CATEGORY_KEY_SITES_BASIC_INFORMATION,
1008                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1009                    initFormNavigatorEntry(
1010                            servletContextName, portalProperties, SITES_FORM_ADD_MISCELLANEOUS,
1011                            FormNavigatorConstants.CATEGORY_KEY_SITES_MISCELLANEOUS,
1012                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1013                    initFormNavigatorEntry(
1014                            servletContextName, portalProperties, SITES_FORM_ADD_SEO,
1015                            FormNavigatorConstants.CATEGORY_KEY_SITES_SEO,
1016                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1017                    initFormNavigatorEntry(
1018                            servletContextName, portalProperties, SITES_FORM_UPDATE_ADVANCED,
1019                            FormNavigatorConstants.CATEGORY_KEY_SITES_ADVANCED,
1020                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1021                    initFormNavigatorEntry(
1022                            servletContextName, portalProperties, SITES_FORM_UPDATE_MAIN,
1023                            FormNavigatorConstants.CATEGORY_KEY_SITES_BASIC_INFORMATION,
1024                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1025                    initFormNavigatorEntry(
1026                            servletContextName, portalProperties,
1027                            SITES_FORM_UPDATE_MISCELLANEOUS,
1028                            FormNavigatorConstants.CATEGORY_KEY_SITES_MISCELLANEOUS,
1029                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1030                    initFormNavigatorEntry(
1031                            servletContextName, portalProperties, SITES_FORM_UPDATE_SEO,
1032                            FormNavigatorConstants.CATEGORY_KEY_SITES_SEO,
1033                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1034    
1035                    initFormNavigatorEntry(
1036                            servletContextName, portalProperties, USERS_FORM_ADD_IDENTIFICATION,
1037                            FormNavigatorConstants.CATEGORY_KEY_USER_IDENTIFICATION,
1038                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1039                    initFormNavigatorEntry(
1040                            servletContextName, portalProperties, USERS_FORM_ADD_MAIN,
1041                            FormNavigatorConstants.CATEGORY_KEY_USER_USER_INFORMATION,
1042                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1043                    initFormNavigatorEntry(
1044                            servletContextName, portalProperties, USERS_FORM_ADD_MISCELLANEOUS,
1045                            FormNavigatorConstants.CATEGORY_KEY_USER_MISCELLANEOUS,
1046                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1047                    initFormNavigatorEntry(
1048                            servletContextName, portalProperties,
1049                            USERS_FORM_MY_ACCOUNT_IDENTIFICATION,
1050                            FormNavigatorConstants.CATEGORY_KEY_USER_IDENTIFICATION,
1051                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1052                    initFormNavigatorEntry(
1053                            servletContextName, portalProperties, USERS_FORM_MY_ACCOUNT_MAIN,
1054                            FormNavigatorConstants.CATEGORY_KEY_USER_USER_INFORMATION,
1055                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1056                    initFormNavigatorEntry(
1057                            servletContextName, portalProperties,
1058                            USERS_FORM_MY_ACCOUNT_MISCELLANEOUS,
1059                            FormNavigatorConstants.CATEGORY_KEY_USER_MISCELLANEOUS,
1060                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1061                    initFormNavigatorEntry(
1062                            servletContextName, portalProperties,
1063                            USERS_FORM_UPDATE_IDENTIFICATION,
1064                            FormNavigatorConstants.CATEGORY_KEY_USER_IDENTIFICATION,
1065                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1066                    initFormNavigatorEntry(
1067                            servletContextName, portalProperties, USERS_FORM_UPDATE_MAIN,
1068                            FormNavigatorConstants.CATEGORY_KEY_USER_USER_INFORMATION,
1069                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1070                    initFormNavigatorEntry(
1071                            servletContextName, portalProperties,
1072                            USERS_FORM_UPDATE_MISCELLANEOUS,
1073                            FormNavigatorConstants.CATEGORY_KEY_USER_MISCELLANEOUS,
1074                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1075            }
1076    
1077            protected void initFormNavigatorEntry(
1078                    String servletContextName, Properties portalProperties,
1079                    String portalPropertiesKey, String categoryKey, String formNavigatorId,
1080                    String jspPath) {
1081    
1082                    String[] formNavigatorSections = StringUtil.split(
1083                            portalProperties.getProperty(portalPropertiesKey));
1084    
1085                    for (int i = 0; i < formNavigatorSections.length; i++) {
1086                            String formNavigatorSection = formNavigatorSections[i];
1087    
1088                            FormNavigatorEntry<Object> deprecatedFormNavigatorEntry =
1089                                    new DeprecatedFormNavigatorEntry(
1090                                            formNavigatorSection, formNavigatorSection, categoryKey,
1091                                            formNavigatorId,
1092                                            "/html/portlet/" + jspPath + "/" + formNavigatorSection +
1093                                                    ".jsp");
1094    
1095                            registerService(
1096                                    servletContextName,
1097                                    formNavigatorId + categoryKey + formNavigatorSection,
1098                                    FormNavigatorEntry.class, deprecatedFormNavigatorEntry,
1099                                    "service.ranking", -i);
1100                    }
1101            }
1102    
1103            protected void initHotDeployListeners(
1104                            String servletContextName, ClassLoader portletClassLoader,
1105                            Properties portalProperties)
1106                    throws Exception {
1107    
1108                    String[] hotDeployListenerClassNames = StringUtil.split(
1109                            portalProperties.getProperty(PropsKeys.HOT_DEPLOY_LISTENERS));
1110    
1111                    if (hotDeployListenerClassNames.length == 0) {
1112                            return;
1113                    }
1114    
1115                    HotDeployListenersContainer hotDeployListenersContainer =
1116                            new HotDeployListenersContainer();
1117    
1118                    _hotDeployListenersContainerMap.put(
1119                            servletContextName, hotDeployListenersContainer);
1120    
1121                    for (String hotDeployListenerClassName : hotDeployListenerClassNames) {
1122                            HotDeployListener hotDeployListener =
1123                                    (HotDeployListener)newInstance(
1124                                            portletClassLoader, HotDeployListener.class,
1125                                            hotDeployListenerClassName);
1126    
1127                            hotDeployListenersContainer.registerHotDeployListener(
1128                                    hotDeployListener);
1129                    }
1130            }
1131    
1132            protected void initIndexerPostProcessors(
1133                            String servletContextName, ClassLoader portletClassLoader,
1134                            Element parentElement)
1135                    throws Exception {
1136    
1137                    List<Element> indexerPostProcessorElements = parentElement.elements(
1138                            "indexer-post-processor");
1139    
1140                    for (Element indexerPostProcessorElement :
1141                                    indexerPostProcessorElements) {
1142    
1143                            String indexerClassName = indexerPostProcessorElement.elementText(
1144                                    "indexer-class-name");
1145    
1146                            if (!checkPermission(
1147                                            PACLConstants.PORTAL_HOOK_PERMISSION_INDEXER,
1148                                            portletClassLoader, indexerClassName,
1149                                            "Rejecting indexer " + indexerClassName)) {
1150    
1151                                    continue;
1152                            }
1153    
1154                            String indexerPostProcessorImpl =
1155                                    indexerPostProcessorElement.elementText(
1156                                            "indexer-post-processor-impl");
1157    
1158                            IndexerPostProcessor indexerPostProcessor =
1159                                    (IndexerPostProcessor)InstanceFactory.newInstance(
1160                                            portletClassLoader, indexerPostProcessorImpl);
1161    
1162                            registerService(
1163                                    servletContextName, indexerPostProcessorImpl,
1164                                    IndexerPostProcessor.class, indexerPostProcessor,
1165                                    "indexer.class.name", indexerClassName);
1166                    }
1167            }
1168    
1169            protected void initLanguageProperties(
1170                            String servletContextName, ClassLoader portletClassLoader,
1171                            Element parentElement)
1172                    throws Exception {
1173    
1174                    List<Element> languagePropertiesElements = parentElement.elements(
1175                            "language-properties");
1176    
1177                    String baseLanguagePropertiesLocation = null;
1178                    URL baseLanguageURL = null;
1179    
1180                    for (Element languagePropertiesElement : languagePropertiesElements) {
1181                            String languagePropertiesLocation =
1182                                    languagePropertiesElement.getText();
1183    
1184                            Locale locale = getLocale(languagePropertiesLocation);
1185    
1186                            if (locale != null) {
1187                                    if (!checkPermission(
1188                                                    PACLConstants.
1189                                                            PORTAL_HOOK_PERMISSION_LANGUAGE_PROPERTIES_LOCALE,
1190                                                    portletClassLoader, locale,
1191                                                    "Rejecting locale " + locale)) {
1192    
1193                                            continue;
1194                                    }
1195                            }
1196    
1197                            URL url = portletClassLoader.getResource(
1198                                    languagePropertiesLocation);
1199    
1200                            if (url == null) {
1201                                    continue;
1202                            }
1203    
1204                            if (locale != null) {
1205                                    String languageId = LocaleUtil.toLanguageId(locale);
1206    
1207                                    try (InputStream inputStream = url.openStream()) {
1208                                            ResourceBundle resourceBundle = new LiferayResourceBundle(
1209                                                    inputStream, StringPool.UTF8);
1210    
1211                                            Map<String, Object> properties = new HashMap<>();
1212    
1213                                            properties.put("language.id", languageId);
1214    
1215                                            registerService(
1216                                                    servletContextName, languagePropertiesLocation,
1217                                                    ResourceBundle.class, resourceBundle, properties);
1218                                    }
1219                            }
1220                            else {
1221                                    baseLanguagePropertiesLocation = languagePropertiesLocation;
1222                                    baseLanguageURL = url;
1223                            }
1224                    }
1225    
1226                    if (baseLanguageURL != null) {
1227                            Locale locale = new Locale(StringPool.BLANK);
1228    
1229                            String languageId = LocaleUtil.toLanguageId(locale);
1230    
1231                            try (InputStream inputStream = baseLanguageURL.openStream()) {
1232                                    ResourceBundle resourceBundle = new LiferayResourceBundle(
1233                                            inputStream, StringPool.UTF8);
1234    
1235                                    Map<String, Object> properties = new HashMap<>();
1236    
1237                                    properties.put("language.id", languageId);
1238    
1239                                    registerService(
1240                                            servletContextName, baseLanguagePropertiesLocation,
1241                                            ResourceBundle.class, resourceBundle, properties);
1242                            }
1243                    }
1244            }
1245    
1246            protected void initModelListener(
1247                            String servletContextName, ClassLoader portletClassLoader,
1248                            String modelName, String modelListenerClassName)
1249                    throws Exception {
1250    
1251                    ModelListener<?> modelListener = (ModelListener<?>)newInstance(
1252                            portletClassLoader, ModelListener.class, modelListenerClassName);
1253    
1254                    registerService(
1255                            servletContextName, modelListenerClassName, ModelListener.class,
1256                            modelListener);
1257            }
1258    
1259            protected void initModelListeners(
1260                            String servletContextName, ClassLoader portletClassLoader,
1261                            Properties portalProperties)
1262                    throws Exception {
1263    
1264                    for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
1265                            String key = (String)entry.getKey();
1266    
1267                            if (!key.startsWith(VALUE_OBJECT_LISTENER)) {
1268                                    continue;
1269                            }
1270    
1271                            String modelName = key.substring(VALUE_OBJECT_LISTENER.length());
1272    
1273                            String[] modelListenerClassNames = StringUtil.split(
1274                                    (String)entry.getValue());
1275    
1276                            for (String modelListenerClassName : modelListenerClassNames) {
1277                                    initModelListener(
1278                                            servletContextName, portletClassLoader, modelName,
1279                                            modelListenerClassName);
1280                            }
1281                    }
1282            }
1283    
1284            protected void initPortalProperties(
1285                            String servletContextName, ClassLoader portletClassLoader,
1286                            Element parentElement)
1287                    throws Exception {
1288    
1289                    String portalPropertiesLocation = parentElement.elementText(
1290                            "portal-properties");
1291    
1292                    if (Validator.isNull(portalPropertiesLocation)) {
1293                            return;
1294                    }
1295    
1296                    Configuration portalPropertiesConfiguration = null;
1297    
1298                    try {
1299                            String name = portalPropertiesLocation;
1300    
1301                            int pos = name.lastIndexOf(".properties");
1302    
1303                            if (pos != -1) {
1304                                    name = name.substring(0, pos);
1305                            }
1306    
1307                            portalPropertiesConfiguration =
1308                                    ConfigurationFactoryUtil.getConfiguration(
1309                                            portletClassLoader, name);
1310                    }
1311                    catch (Exception e) {
1312                            _log.error("Unable to read " + portalPropertiesLocation, e);
1313                    }
1314    
1315                    if (portalPropertiesConfiguration == null) {
1316                            return;
1317                    }
1318    
1319                    Properties portalProperties =
1320                            portalPropertiesConfiguration.getProperties();
1321    
1322                    if (portalProperties.isEmpty()) {
1323                            return;
1324                    }
1325    
1326                    Set<Object> set = portalProperties.keySet();
1327    
1328                    Iterator<Object> iterator = set.iterator();
1329    
1330                    while (iterator.hasNext()) {
1331                            String key = (String)iterator.next();
1332    
1333                            if (!checkPermission(
1334                                            PACLConstants.PORTAL_HOOK_PERMISSION_PORTAL_PROPERTIES_KEY,
1335                                            portletClassLoader, key,
1336                                            "Rejecting portal.properties key " + key)) {
1337    
1338                                    iterator.remove();
1339                            }
1340                    }
1341    
1342                    Properties unfilteredPortalProperties =
1343                            (Properties)portalProperties.clone();
1344    
1345                    portalProperties.remove(PropsKeys.RELEASE_INFO_BUILD_NUMBER);
1346                    portalProperties.remove(PropsKeys.RELEASE_INFO_PREVIOUS_BUILD_NUMBER);
1347                    portalProperties.remove(PropsKeys.UPGRADE_PROCESSES);
1348    
1349                    _portalPropertiesMap.put(servletContextName, portalProperties);
1350    
1351                    // Initialize properties, auto logins, model listeners, and events in
1352                    // that specific order. Events have to be loaded last because they may
1353                    // require model listeners to have been registered.
1354    
1355                    initPortalProperties(
1356                            servletContextName, portletClassLoader, portalProperties,
1357                            unfilteredPortalProperties);
1358                    initAuthFailures(
1359                            servletContextName, portletClassLoader, portalProperties);
1360                    initAutoDeployListeners(
1361                            servletContextName, portletClassLoader, portalProperties);
1362                    initAutoLogins(
1363                            servletContextName, portletClassLoader, portalProperties);
1364                    initAuthenticators(
1365                            servletContextName, portletClassLoader, portalProperties);
1366                    initAuthVerifiers(
1367                            servletContextName, portletClassLoader, portalProperties);
1368                    initFormNavigatorEntries(servletContextName, portalProperties);
1369                    initHotDeployListeners(
1370                            servletContextName, portletClassLoader, portalProperties);
1371                    initModelListeners(
1372                            servletContextName, portletClassLoader, portalProperties);
1373                    initEvents(servletContextName, portletClassLoader, portalProperties);
1374            }
1375    
1376            protected void initPortalProperties(
1377                            String servletContextName, ClassLoader portletClassLoader,
1378                            Properties portalProperties, Properties unfilteredPortalProperties)
1379                    throws Exception {
1380    
1381                    PropsUtil.addProperties(portalProperties);
1382    
1383                    if (_log.isDebugEnabled() && portalProperties.containsKey(LOCALES)) {
1384                            _log.debug(
1385                                    "Portlet locales " + portalProperties.getProperty(LOCALES));
1386                            _log.debug("Merged locales " + PropsUtil.get(LOCALES));
1387                            _log.debug(
1388                                    "Merged locales array length " +
1389                                            PropsUtil.getArray(LOCALES).length);
1390                    }
1391    
1392                    for (String key : _PROPS_VALUES_OBSOLETE) {
1393                            if (_log.isInfoEnabled() && portalProperties.contains(key)) {
1394                                    _log.info("Portal property \"" + key + "\" is obsolete");
1395                            }
1396                    }
1397    
1398                    resetPortalProperties(servletContextName, portalProperties, true);
1399    
1400                    if (portalProperties.containsKey(PropsKeys.AUTH_PUBLIC_PATHS)) {
1401                            initAuthPublicPaths(servletContextName, portalProperties);
1402                    }
1403    
1404                    if (portalProperties.containsKey(PropsKeys.AUTH_TOKEN_IMPL)) {
1405                            String authTokenClassName = portalProperties.getProperty(
1406                                    PropsKeys.AUTH_TOKEN_IMPL);
1407    
1408                            AuthToken authToken = (AuthToken)newInstance(
1409                                    portletClassLoader, AuthToken.class, authTokenClassName);
1410    
1411                            registerService(
1412                                    servletContextName, authTokenClassName, AuthToken.class,
1413                                    authToken);
1414                    }
1415    
1416                    if (portalProperties.containsKey(PropsKeys.CAPTCHA_ENGINE_IMPL)) {
1417                            String captchaClassName = portalProperties.getProperty(
1418                                    PropsKeys.CAPTCHA_ENGINE_IMPL);
1419    
1420                            Captcha captcha = (Captcha)newInstance(
1421                                    portletClassLoader, Captcha.class, captchaClassName);
1422    
1423                            CaptchaImpl captchaImpl = null;
1424    
1425                            Captcha currentCaptcha = CaptchaUtil.getCaptcha();
1426    
1427                            if (currentCaptcha instanceof DoPrivilegedBean) {
1428                                    DoPrivilegedBean doPrivilegedBean =
1429                                            (DoPrivilegedBean)currentCaptcha;
1430    
1431                                    captchaImpl = (CaptchaImpl)doPrivilegedBean.getActualBean();
1432                            }
1433                            else {
1434                                    captchaImpl = (CaptchaImpl)currentCaptcha;
1435                            }
1436    
1437                            captchaImpl.setCaptcha(captcha);
1438                    }
1439    
1440                    if (portalProperties.containsKey(
1441                                    PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS)) {
1442    
1443                            String controlPanelEntryClassName = portalProperties.getProperty(
1444                                    PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS);
1445    
1446                            ControlPanelEntry controlPanelEntry =
1447                                    (ControlPanelEntry)newInstance(
1448                                            portletClassLoader, ControlPanelEntry.class,
1449                                            controlPanelEntryClassName);
1450    
1451                            registerService(
1452                                    servletContextName, controlPanelEntryClassName,
1453                                    ControlPanelEntry.class, controlPanelEntry);
1454                    }
1455    
1456                    if (portalProperties.containsKey(PropsKeys.DL_FILE_ENTRY_PROCESSORS)) {
1457                            String[] dlProcessorClassNames = StringUtil.split(
1458                                    portalProperties.getProperty(
1459                                            PropsKeys.DL_FILE_ENTRY_PROCESSORS));
1460    
1461                            DLFileEntryProcessorContainer dlFileEntryProcessorContainer =
1462                                    new DLFileEntryProcessorContainer();
1463    
1464                            _dlFileEntryProcessorContainerMap.put(
1465                                    servletContextName, dlFileEntryProcessorContainer);
1466    
1467                            for (String dlProcessorClassName : dlProcessorClassNames) {
1468                                    DLProcessor dlProcessor =
1469                                            (DLProcessor)InstanceFactory.newInstance(
1470                                                    portletClassLoader, dlProcessorClassName);
1471    
1472                                    dlProcessor = (DLProcessor)newInstance(
1473                                            portletClassLoader,
1474                                            ReflectionUtil.getInterfaces(
1475                                                    dlProcessor, portletClassLoader),
1476                                            dlProcessorClassName);
1477    
1478                                    dlFileEntryProcessorContainer.registerDLProcessor(dlProcessor);
1479                            }
1480                    }
1481    
1482                    if (portalProperties.containsKey(PropsKeys.DL_REPOSITORY_IMPL)) {
1483                            String[] dlRepositoryClassNames = StringUtil.split(
1484                                    portalProperties.getProperty(PropsKeys.DL_REPOSITORY_IMPL));
1485    
1486                            DLRepositoryContainer dlRepositoryContainer =
1487                                    new DLRepositoryContainer();
1488    
1489                            _dlRepositoryContainerMap.put(
1490                                    servletContextName, dlRepositoryContainer);
1491    
1492                            for (String dlRepositoryClassName : dlRepositoryClassNames) {
1493                                    ExternalRepositoryFactory externalRepositoryFactory =
1494                                            new ExternalRepositoryFactoryImpl(
1495                                                    dlRepositoryClassName, portletClassLoader);
1496    
1497                                    dlRepositoryContainer.registerRepositoryFactory(
1498                                            dlRepositoryClassName, externalRepositoryFactory);
1499                            }
1500                    }
1501    
1502                    if (portalProperties.containsKey(PropsKeys.DL_STORE_ANTIVIRUS_IMPL)) {
1503                            String antivirusScannerClassName = portalProperties.getProperty(
1504                                    PropsKeys.DL_STORE_ANTIVIRUS_IMPL);
1505    
1506                            AntivirusScanner antivirusScanner = (AntivirusScanner)newInstance(
1507                                    portletClassLoader, AntivirusScanner.class,
1508                                    antivirusScannerClassName);
1509    
1510                            AntivirusScannerWrapper antivirusScannerWrapper =
1511                                    (AntivirusScannerWrapper)
1512                                            AntivirusScannerUtil.getAntivirusScanner();
1513    
1514                            antivirusScannerWrapper.setAntivirusScanner(antivirusScanner);
1515                    }
1516    
1517                    if (portalProperties.containsKey(PropsKeys.DL_STORE_IMPL)) {
1518                            StoreFactory storeFactory = StoreFactory.getInstance();
1519    
1520                            String storeClassName = portalProperties.getProperty(
1521                                    PropsKeys.DL_STORE_IMPL);
1522    
1523                            storeFactory.setStore(storeClassName);
1524                    }
1525    
1526                    if (portalProperties.containsKey(
1527                                    PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL)) {
1528    
1529                            String attributesTransformerClassName =
1530                                    portalProperties.getProperty(
1531                                            PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL);
1532    
1533                            AttributesTransformer attributesTransformer =
1534                                    (AttributesTransformer)newInstance(
1535                                            portletClassLoader, AttributesTransformer.class,
1536                                            attributesTransformerClassName);
1537    
1538                            registerService(
1539                                    servletContextName, attributesTransformerClassName,
1540                                    AttributesTransformer.class, attributesTransformer);
1541                    }
1542    
1543                    if (portalProperties.containsKey(LOCK_LISTENERS)) {
1544                            String[] lockListenerClassNames = StringUtil.split(
1545                                    portalProperties.getProperty(LOCK_LISTENERS));
1546    
1547                            for (String lockListenerClassName : lockListenerClassNames) {
1548                                    LockListener lockListener = (LockListener)newInstance(
1549                                            portletClassLoader, LockListener.class,
1550                                            lockListenerClassName);
1551    
1552                                    registerService(
1553                                            servletContextName, lockListenerClassName,
1554                                            LockListener.class, lockListener);
1555                            }
1556                    }
1557    
1558                    if (portalProperties.containsKey(PropsKeys.MAIL_HOOK_IMPL)) {
1559                            String mailHookClassName = portalProperties.getProperty(
1560                                    PropsKeys.MAIL_HOOK_IMPL);
1561    
1562                            com.liferay.mail.kernel.util.Hook mailHook =
1563                                    (com.liferay.mail.kernel.util.Hook)newInstance(
1564                                            portletClassLoader, com.liferay.mail.kernel.util.Hook.class,
1565                                            mailHookClassName);
1566    
1567                            registerService(
1568                                    servletContextName, mailHookClassName,
1569                                    com.liferay.mail.kernel.util.Hook.class, mailHook);
1570                    }
1571    
1572                    if (portalProperties.containsKey(
1573                                    PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS)) {
1574    
1575                            String organizationMembershipPolicyClassName =
1576                                    portalProperties.getProperty(
1577                                            PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS);
1578    
1579                            OrganizationMembershipPolicy organizationMembershipPolicy =
1580                                    (OrganizationMembershipPolicy)newInstance(
1581                                            portletClassLoader, OrganizationMembershipPolicy.class,
1582                                            organizationMembershipPolicyClassName);
1583    
1584                            registerService(
1585                                    servletContextName, organizationMembershipPolicyClassName,
1586                                    OrganizationMembershipPolicy.class,
1587                                    organizationMembershipPolicy);
1588                    }
1589    
1590                    if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_ROLES)) {
1591                            String roleMembershipPolicyClassName = portalProperties.getProperty(
1592                                    PropsKeys.MEMBERSHIP_POLICY_ROLES);
1593    
1594                            RoleMembershipPolicy roleMembershipPolicy =
1595                                    (RoleMembershipPolicy)newInstance(
1596                                            portletClassLoader, RoleMembershipPolicy.class,
1597                                            roleMembershipPolicyClassName);
1598    
1599                            registerService(
1600                                    servletContextName, roleMembershipPolicyClassName,
1601                                    RoleMembershipPolicy.class, roleMembershipPolicy);
1602                    }
1603    
1604                    if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_SITES)) {
1605                            String siteMembershipPolicyClassName = portalProperties.getProperty(
1606                                    PropsKeys.MEMBERSHIP_POLICY_SITES);
1607    
1608                            SiteMembershipPolicy siteMembershipPolicy =
1609                                    (SiteMembershipPolicy)newInstance(
1610                                            portletClassLoader, SiteMembershipPolicy.class,
1611                                            siteMembershipPolicyClassName);
1612    
1613                            registerService(
1614                                    servletContextName, siteMembershipPolicyClassName,
1615                                    SiteMembershipPolicy.class, siteMembershipPolicy);
1616                    }
1617    
1618                    if (portalProperties.containsKey(
1619                                    PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS)) {
1620    
1621                            String userGroupMembershipPolicyClassName =
1622                                    portalProperties.getProperty(
1623                                            PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS);
1624    
1625                            UserGroupMembershipPolicy userGroupMembershipPolicy =
1626                                    (UserGroupMembershipPolicy)newInstance(
1627                                            portletClassLoader, UserGroupMembershipPolicy.class,
1628                                            userGroupMembershipPolicyClassName);
1629    
1630                            registerService(
1631                                    servletContextName, userGroupMembershipPolicyClassName,
1632                                    UserGroupMembershipPolicy.class, userGroupMembershipPolicy);
1633                    }
1634    
1635                    if (portalProperties.containsKey(PropsKeys.PASSWORDS_TOOLKIT)) {
1636                            String toolkitClassName = portalProperties.getProperty(
1637                                    PropsKeys.PASSWORDS_TOOLKIT);
1638    
1639                            Toolkit toolkit = (Toolkit)newInstance(
1640                                    portletClassLoader, Toolkit.class, toolkitClassName);
1641    
1642                            registerService(
1643                                    servletContextName, toolkitClassName, Toolkit.class, toolkit);
1644                    }
1645    
1646                    if (portalProperties.containsKey(PropsKeys.PHONE_NUMBER_FORMAT_IMPL)) {
1647                            String phoneNumberFormatClassName = portalProperties.getProperty(
1648                                    PropsKeys.PHONE_NUMBER_FORMAT_IMPL);
1649    
1650                            PhoneNumberFormat phoneNumberFormat =
1651                                    (PhoneNumberFormat)newInstance(
1652                                            portletClassLoader, PhoneNumberFormat.class,
1653                                            phoneNumberFormatClassName);
1654    
1655                            registerService(
1656                                    servletContextName, phoneNumberFormatClassName,
1657                                    PhoneNumberFormat.class, phoneNumberFormat);
1658                    }
1659    
1660                    if (portalProperties.containsKey(PropsKeys.SANITIZER_IMPL)) {
1661                            String[] sanitizerClassNames = StringUtil.split(
1662                                    portalProperties.getProperty(PropsKeys.SANITIZER_IMPL));
1663    
1664                            for (String sanitizerClassName : sanitizerClassNames) {
1665                                    Sanitizer sanitizer = (Sanitizer)newInstance(
1666                                            portletClassLoader, Sanitizer.class, sanitizerClassName);
1667    
1668                                    registerService(
1669                                            servletContextName, sanitizerClassName, Sanitizer.class,
1670                                            sanitizer);
1671                            }
1672                    }
1673    
1674                    if (portalProperties.containsKey(
1675                                    PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR)) {
1676    
1677                            String emailAddressGeneratorClassName =
1678                                    portalProperties.getProperty(
1679                                            PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR);
1680    
1681                            EmailAddressGenerator emailAddressGenerator =
1682                                    (EmailAddressGenerator)newInstance(
1683                                            portletClassLoader, EmailAddressGenerator.class,
1684                                            emailAddressGeneratorClassName);
1685    
1686                            registerService(
1687                                    servletContextName, emailAddressGeneratorClassName,
1688                                    EmailAddressGenerator.class, emailAddressGenerator);
1689                    }
1690    
1691                    if (portalProperties.containsKey(
1692                                    PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR)) {
1693    
1694                            String emailAddressValidatorClassName =
1695                                    portalProperties.getProperty(
1696                                            PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR);
1697    
1698                            EmailAddressValidator emailAddressValidator =
1699                                    (EmailAddressValidator)newInstance(
1700                                            portletClassLoader, EmailAddressValidator.class,
1701                                            emailAddressValidatorClassName);
1702    
1703                            registerService(
1704                                    servletContextName, emailAddressValidatorClassName,
1705                                    EmailAddressValidator.class, emailAddressValidator);
1706                    }
1707    
1708                    if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_GENERATOR)) {
1709                            String fullNameGeneratorClassName = portalProperties.getProperty(
1710                                    PropsKeys.USERS_FULL_NAME_GENERATOR);
1711    
1712                            FullNameGenerator fullNameGenerator =
1713                                    (FullNameGenerator)newInstance(
1714                                            portletClassLoader, FullNameGenerator.class,
1715                                            fullNameGeneratorClassName);
1716    
1717                            registerService(
1718                                    servletContextName, fullNameGeneratorClassName,
1719                                    FullNameGenerator.class, fullNameGenerator);
1720                    }
1721    
1722                    if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_VALIDATOR)) {
1723                            String fullNameValidatorClassName = portalProperties.getProperty(
1724                                    PropsKeys.USERS_FULL_NAME_VALIDATOR);
1725    
1726                            FullNameValidator fullNameValidator =
1727                                    (FullNameValidator)newInstance(
1728                                            portletClassLoader, FullNameValidator.class,
1729                                            fullNameValidatorClassName);
1730    
1731                            registerService(
1732                                    servletContextName, fullNameValidatorClassName,
1733                                    FullNameValidator.class, fullNameValidator);
1734                    }
1735    
1736                    if (portalProperties.containsKey(
1737                                    PropsKeys.USERS_SCREEN_NAME_GENERATOR)) {
1738    
1739                            String screenNameGeneratorClassName = portalProperties.getProperty(
1740                                    PropsKeys.USERS_SCREEN_NAME_GENERATOR);
1741    
1742                            ScreenNameGenerator screenNameGenerator =
1743                                    (ScreenNameGenerator)newInstance(
1744                                            portletClassLoader, ScreenNameGenerator.class,
1745                                            screenNameGeneratorClassName);
1746    
1747                            registerService(
1748                                    servletContextName, screenNameGeneratorClassName,
1749                                    ScreenNameGenerator.class, screenNameGenerator);
1750                    }
1751    
1752                    if (portalProperties.containsKey(
1753                                    PropsKeys.USERS_SCREEN_NAME_VALIDATOR)) {
1754    
1755                            String screenNameValidatorClassName = portalProperties.getProperty(
1756                                    PropsKeys.USERS_SCREEN_NAME_VALIDATOR);
1757    
1758                            ScreenNameValidator screenNameValidator =
1759                                    (ScreenNameValidator)newInstance(
1760                                            portletClassLoader, ScreenNameValidator.class,
1761                                            screenNameValidatorClassName);
1762    
1763                            registerService(
1764                                    servletContextName, screenNameValidatorClassName,
1765                                    ScreenNameValidator.class, screenNameValidator);
1766                    }
1767    
1768                    for (String tokenWhitelistName : _TOKEN_WHITELIST_NAMES) {
1769                            if (containsKey(portalProperties, tokenWhitelistName)) {
1770                                    initTokensWhitelists(servletContextName, portalProperties);
1771    
1772                                    break;
1773                            }
1774                    }
1775    
1776                    Set<String> liferayFilterClassNames =
1777                            LiferayFilterTracker.getClassNames();
1778    
1779                    for (String liferayFilterClassName : liferayFilterClassNames) {
1780                            if (!portalProperties.containsKey(liferayFilterClassName)) {
1781                                    continue;
1782                            }
1783    
1784                            boolean filterEnabled = GetterUtil.getBoolean(
1785                                    portalProperties.getProperty(liferayFilterClassName));
1786    
1787                            Set<LiferayFilter> liferayFilters =
1788                                    LiferayFilterTracker.getLiferayFilters(liferayFilterClassName);
1789    
1790                            for (LiferayFilter liferayFilter : liferayFilters) {
1791                                    liferayFilter.setFilterEnabled(filterEnabled);
1792                            }
1793                    }
1794    
1795                    if (unfilteredPortalProperties.containsKey(
1796                                    PropsKeys.RELEASE_INFO_BUILD_NUMBER) ||
1797                            unfilteredPortalProperties.containsKey(
1798                                    PropsKeys.UPGRADE_PROCESSES)) {
1799    
1800                            String[] upgradeProcessClassNames = StringUtil.split(
1801                                    unfilteredPortalProperties.getProperty(
1802                                            PropsKeys.UPGRADE_PROCESSES));
1803    
1804                            List<UpgradeProcess> upgradeProcesses =
1805                                    UpgradeProcessUtil.initUpgradeProcesses(
1806                                            portletClassLoader, upgradeProcessClassNames);
1807    
1808                            ReleaseLocalServiceUtil.updateRelease(
1809                                    servletContextName, upgradeProcesses,
1810                                    unfilteredPortalProperties);
1811                    }
1812            }
1813    
1814            protected void initServices(
1815                            String servletContextName, ClassLoader portletClassLoader,
1816                            Element parentElement)
1817                    throws Exception {
1818    
1819                    List<Element> serviceElements = parentElement.elements("service");
1820    
1821                    for (Element serviceElement : serviceElements) {
1822                            String serviceType = serviceElement.elementText("service-type");
1823                            String serviceImpl = serviceElement.elementText("service-impl");
1824    
1825                            if (!checkPermission(
1826                                            PACLConstants.PORTAL_HOOK_PERMISSION_SERVICE,
1827                                            portletClassLoader, serviceType,
1828                                            "Rejecting service " + serviceImpl)) {
1829    
1830                                    continue;
1831                            }
1832    
1833                            Class<?> serviceTypeClass = portletClassLoader.loadClass(
1834                                    serviceType);
1835    
1836                            Class<?> serviceImplClass = portletClassLoader.loadClass(
1837                                    serviceImpl);
1838    
1839                            Constructor<?> serviceImplConstructor =
1840                                    serviceImplClass.getConstructor(
1841                                            new Class<?>[] {serviceTypeClass});
1842    
1843                            Object serviceProxy = null;
1844    
1845                            try {
1846                                    serviceProxy = PortalBeanLocatorUtil.locate(serviceType);
1847                            }
1848                            catch (BeanLocatorException ble) {
1849                                    Registry registry = RegistryUtil.getRegistry();
1850    
1851                                    serviceProxy = registry.getService(serviceTypeClass);
1852                            }
1853    
1854                            if (ProxyUtil.isProxyClass(serviceProxy.getClass())) {
1855                                    initServices(
1856                                            servletContextName, portletClassLoader, serviceType,
1857                                            serviceTypeClass, serviceImplConstructor, serviceProxy);
1858                            }
1859                            else {
1860                                    _log.error(
1861                                            "Service hooks require Spring to be configured to use " +
1862                                                    "JdkDynamicProxy and will not work with CGLIB");
1863                            }
1864                    }
1865            }
1866    
1867            protected void initServices(
1868                            String servletContextName, ClassLoader portletClassLoader,
1869                            String serviceType, Class<?> serviceTypeClass,
1870                            Constructor<?> serviceImplConstructor, Object serviceProxy)
1871                    throws Exception {
1872    
1873                    AdvisedSupport advisedSupport = ServiceBeanAopProxy.getAdvisedSupport(
1874                            serviceProxy);
1875    
1876                    TargetSource targetSource = advisedSupport.getTargetSource();
1877    
1878                    Object previousService = targetSource.getTarget();
1879    
1880                    ServiceWrapper<?> serviceWrapper =
1881                            (ServiceWrapper<?>)serviceImplConstructor.newInstance(
1882                                    previousService);
1883    
1884                    registerService(
1885                            servletContextName, serviceImplConstructor, ServiceWrapper.class,
1886                            serviceWrapper);
1887            }
1888    
1889            protected Filter initServletFilter(
1890                            String filterClassName, ClassLoader portletClassLoader)
1891                    throws Exception {
1892    
1893                    Filter filter = (Filter)InstanceFactory.newInstance(
1894                            portletClassLoader, filterClassName);
1895    
1896                    List<Class<?>> interfaces = new ArrayList<>();
1897    
1898                    if (filter instanceof TryFilter) {
1899                            interfaces.add(TryFilter.class);
1900                    }
1901    
1902                    if (filter instanceof TryFinallyFilter) {
1903                            interfaces.add(TryFinallyFilter.class);
1904                    }
1905    
1906                    if (filter instanceof WrapHttpServletRequestFilter) {
1907                            interfaces.add(WrapHttpServletRequestFilter.class);
1908                    }
1909    
1910                    if (filter instanceof WrapHttpServletResponseFilter) {
1911                            interfaces.add(WrapHttpServletResponseFilter.class);
1912                    }
1913    
1914                    if (filter instanceof LiferayFilter) {
1915                            interfaces.add(LiferayFilter.class);
1916                    }
1917                    else {
1918                            interfaces.add(Filter.class);
1919                    }
1920    
1921                    filter = (Filter)ProxyUtil.newProxyInstance(
1922                            portletClassLoader,
1923                            interfaces.toArray(new Class[interfaces.size()]),
1924                            new ClassLoaderBeanHandler(filter, portletClassLoader));
1925    
1926                    return filter;
1927            }
1928    
1929            protected void initServletFilters(
1930                            ServletContext servletContext, String servletContextName,
1931                            ClassLoader portletClassLoader, Element parentElement)
1932                    throws Exception {
1933    
1934                    List<Element> servletFilterElements = parentElement.elements(
1935                            "servlet-filter");
1936    
1937                    if (!servletFilterElements.isEmpty() &&
1938                            !checkPermission(
1939                                    PACLConstants.PORTAL_HOOK_PERMISSION_SERVLET_FILTERS,
1940                                    portletClassLoader, null, "Rejecting servlet filters")) {
1941    
1942                            return;
1943                    }
1944    
1945                    Map<String, Tuple> filterTuples = new HashMap<>();
1946    
1947                    List<Element> servletFilterMappingElements = parentElement.elements(
1948                            "servlet-filter-mapping");
1949    
1950                    for (Element servletFilterMappingElement :
1951                                    servletFilterMappingElements) {
1952    
1953                            String servletFilterName = servletFilterMappingElement.elementText(
1954                                    "servlet-filter-name");
1955                            String afterFilter = servletFilterMappingElement.elementText(
1956                                    "after-filter");
1957                            String beforeFilter = servletFilterMappingElement.elementText(
1958                                    "before-filter");
1959    
1960                            List<Element> urlPatternElements =
1961                                    servletFilterMappingElement.elements("url-pattern");
1962    
1963                            List<String> urlPatterns = new ArrayList<>();
1964    
1965                            for (Element urlPatternElement : urlPatternElements) {
1966                                    String urlPattern = urlPatternElement.getTextTrim();
1967    
1968                                    urlPatterns.add(urlPattern);
1969                            }
1970    
1971                            List<Element> dispatcherElements =
1972                                    servletFilterMappingElement.elements("dispatcher");
1973    
1974                            List<String> dispatchers = new ArrayList<>();
1975    
1976                            for (Element dispatcherElement : dispatcherElements) {
1977                                    String dispatcher = dispatcherElement.getTextTrim();
1978    
1979                                    dispatcher = StringUtil.toUpperCase(dispatcher);
1980    
1981                                    dispatchers.add(dispatcher);
1982                            }
1983    
1984                            filterTuples.put(
1985                                    servletFilterName,
1986                                    new Tuple(afterFilter, beforeFilter, dispatchers, urlPatterns));
1987                    }
1988    
1989                    for (Element servletFilterElement : servletFilterElements) {
1990                            String servletFilterName = servletFilterElement.elementText(
1991                                    "servlet-filter-name");
1992                            String servletFilterImpl = servletFilterElement.elementText(
1993                                    "servlet-filter-impl");
1994    
1995                            List<Element> initParamElements = servletFilterElement.elements(
1996                                    "init-param");
1997    
1998                            Map<String, Object> properties = new HashMap<>();
1999    
2000                            for (Element initParamElement : initParamElements) {
2001                                    String paramName = initParamElement.elementText("param-name");
2002                                    String paramValue = initParamElement.elementText("param-value");
2003    
2004                                    properties.put("init.param." + paramName, paramValue);
2005                            }
2006    
2007                            Tuple filterTuple = filterTuples.get(servletFilterName);
2008    
2009                            properties.put("after-filter", filterTuple.getObject(0));
2010                            properties.put("before-filter", filterTuple.getObject(1));
2011                            properties.put("dispatcher", filterTuple.getObject(2));
2012                            properties.put(
2013                                    "servlet-context-name",
2014                                    PortalContextLoaderListener.getPortalServletContextName());
2015                            properties.put("servlet-filter-name", servletFilterName);
2016                            properties.put("url-pattern", filterTuple.getObject(3));
2017    
2018                            Filter filter = initServletFilter(
2019                                    servletFilterImpl, portletClassLoader);
2020    
2021                            registerService(
2022                                    servletContextName, servletFilterName, Filter.class, filter,
2023                                    properties);
2024                    }
2025            }
2026    
2027            protected void initStrutsAction(
2028                            String servletContextName, ClassLoader portletClassLoader,
2029                            String strutsActionPath, String strutsActionClassName)
2030                    throws Exception {
2031    
2032                    Object strutsActionObject = InstanceFactory.newInstance(
2033                            portletClassLoader, strutsActionClassName);
2034    
2035                    if (strutsActionObject instanceof StrutsAction) {
2036                            StrutsAction strutsAction =
2037                                    (StrutsAction)ProxyUtil.newProxyInstance(
2038                                            portletClassLoader, new Class[] {StrutsAction.class},
2039                                            new ClassLoaderBeanHandler(
2040                                                    strutsActionObject, portletClassLoader));
2041    
2042                            registerService(
2043                                    servletContextName, strutsActionClassName, StrutsAction.class,
2044                                    strutsAction, "path", strutsActionPath);
2045                    }
2046                    else {
2047                            StrutsPortletAction strutsPortletAction =
2048                                    (StrutsPortletAction)ProxyUtil.newProxyInstance(
2049                                            portletClassLoader, new Class[] {StrutsPortletAction.class},
2050                                            new ClassLoaderBeanHandler(
2051                                                    strutsActionObject, portletClassLoader));
2052    
2053                            registerService(
2054                                    servletContextName, strutsActionClassName,
2055                                    StrutsPortletAction.class, strutsPortletAction, "path",
2056                                    strutsActionPath);
2057                    }
2058            }
2059    
2060            protected void initStrutsActions(
2061                            String servletContextName, ClassLoader portletClassLoader,
2062                            Element parentElement)
2063                    throws Exception {
2064    
2065                    List<Element> strutsActionElements = parentElement.elements(
2066                            "struts-action");
2067    
2068                    for (Element strutsActionElement : strutsActionElements) {
2069                            String strutsActionPath = strutsActionElement.elementText(
2070                                    "struts-action-path");
2071    
2072                            if (!checkPermission(
2073                                            PACLConstants.PORTAL_HOOK_PERMISSION_STRUTS_ACTION_PATH,
2074                                            portletClassLoader, strutsActionPath,
2075                                            "Rejecting struts action path " + strutsActionPath)) {
2076    
2077                                    continue;
2078                            }
2079    
2080                            String strutsActionImpl = strutsActionElement.elementText(
2081                                    "struts-action-impl");
2082    
2083                            initStrutsAction(
2084                                    servletContextName, portletClassLoader, strutsActionPath,
2085                                    strutsActionImpl);
2086                    }
2087            }
2088    
2089            protected void initTokensWhitelists(
2090                            String servletContextName, Properties portalProperties)
2091                    throws Exception {
2092    
2093                    for (String tokenWhitelistName : _TOKEN_WHITELIST_NAMES) {
2094                            String propertyValue = portalProperties.getProperty(
2095                                    tokenWhitelistName);
2096    
2097                            if (Validator.isBlank(propertyValue)) {
2098                                    continue;
2099                            }
2100    
2101                            registerService(
2102                                    servletContextName, tokenWhitelistName + propertyValue,
2103                                    Object.class, new Object(), tokenWhitelistName,
2104                                    StringUtil.split(propertyValue));
2105                    }
2106            }
2107    
2108            protected <S, T> Map<S, T> newMap() {
2109                    return new ConcurrentHashMap<>();
2110            }
2111    
2112            protected void resetPortalProperties(
2113                            String servletContextName, Properties portalProperties,
2114                            boolean initPhase)
2115                    throws Exception {
2116    
2117                    for (String key : _PROPS_VALUES_BOOLEAN) {
2118                            String fieldName = StringUtil.replace(
2119                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2120                                    CharPool.UNDERLINE);
2121    
2122                            if (!containsKey(portalProperties, key)) {
2123                                    continue;
2124                            }
2125    
2126                            try {
2127                                    Field field = PropsValues.class.getField(fieldName);
2128    
2129                                    Boolean value = Boolean.valueOf(
2130                                            GetterUtil.getBoolean(PropsUtil.get(key)));
2131    
2132                                    field.setBoolean(null, value);
2133                            }
2134                            catch (Exception e) {
2135                                    _log.error(
2136                                            "Error setting field " + fieldName + ": " + e.getMessage());
2137                            }
2138                    }
2139    
2140                    for (String key : _PROPS_VALUES_INTEGER) {
2141                            String fieldName = StringUtil.replace(
2142                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2143                                    CharPool.UNDERLINE);
2144    
2145                            if (!containsKey(portalProperties, key)) {
2146                                    continue;
2147                            }
2148    
2149                            try {
2150                                    Field field = PropsValues.class.getField(fieldName);
2151    
2152                                    Integer value = Integer.valueOf(
2153                                            GetterUtil.getInteger(PropsUtil.get(key)));
2154    
2155                                    field.setInt(null, value);
2156                            }
2157                            catch (Exception e) {
2158                                    _log.error(
2159                                            "Error setting field " + fieldName + ": " + e.getMessage());
2160                            }
2161                    }
2162    
2163                    for (String key : _PROPS_VALUES_LONG) {
2164                            String fieldName = StringUtil.replace(
2165                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2166                                    CharPool.UNDERLINE);
2167    
2168                            if (!containsKey(portalProperties, key)) {
2169                                    continue;
2170                            }
2171    
2172                            try {
2173                                    Field field = PropsValues.class.getField(fieldName);
2174    
2175                                    Long value = Long.valueOf(
2176                                            GetterUtil.getLong(PropsUtil.get(key)));
2177    
2178                                    field.setLong(null, value);
2179                            }
2180                            catch (Exception e) {
2181                                    _log.error(
2182                                            "Error setting field " + fieldName + ": " + e.getMessage());
2183                            }
2184                    }
2185    
2186                    for (String key : _PROPS_VALUES_STRING) {
2187                            String fieldName = StringUtil.replace(
2188                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2189                                    CharPool.UNDERLINE);
2190    
2191                            if (!containsKey(portalProperties, key)) {
2192                                    continue;
2193                            }
2194    
2195                            try {
2196                                    Field field = PropsValues.class.getField(fieldName);
2197    
2198                                    String value = GetterUtil.getString(PropsUtil.get(key));
2199    
2200                                    field.set(null, value);
2201                            }
2202                            catch (Exception e) {
2203                                    _log.error(
2204                                            "Error setting field " + fieldName + ": " + e.getMessage());
2205                            }
2206                    }
2207    
2208                    resetPortalPropertiesStringArray(
2209                            servletContextName, portalProperties, initPhase,
2210                            _PROPS_VALUES_MERGE_STRING_ARRAY, _mergeStringArraysContainerMap);
2211    
2212                    resetPortalPropertiesStringArray(
2213                            servletContextName, portalProperties, initPhase,
2214                            _PROPS_VALUES_OVERRIDE_STRING_ARRAY,
2215                            _overrideStringArraysContainerMap);
2216    
2217                    if (containsKey(portalProperties, LOCALES) ||
2218                            containsKey(portalProperties, LOCALES_BETA)) {
2219    
2220                            PropsValues.LOCALES = PropsUtil.getArray(LOCALES);
2221    
2222                            LanguageUtil.init();
2223                    }
2224    
2225                    if (containsKey(portalProperties, LOCALES_ENABLED)) {
2226                            PropsValues.LOCALES_ENABLED = PropsUtil.getArray(LOCALES_ENABLED);
2227    
2228                            LanguageUtil.init();
2229                    }
2230    
2231                    if (containsKey(
2232                                    portalProperties, PORTLET_INTERRUPTED_REQUEST_WHITELIST)) {
2233    
2234                            InterruptedPortletRequestWhitelistUtil.
2235                                    resetPortletInvocationWhitelist();
2236                    }
2237    
2238                    if (containsKey(
2239                                    portalProperties,
2240                                    PORTLET_INTERRUPTED_REQUEST_WHITELIST_ACTIONS)) {
2241    
2242                            InterruptedPortletRequestWhitelistUtil.
2243                                    resetPortletInvocationWhitelistActions();
2244                    }
2245    
2246                    CacheUtil.clearCache();
2247    
2248                    JavaScriptBundleUtil.clearCache();
2249            }
2250    
2251            protected void resetPortalPropertiesStringArray(
2252                    String servletContextName, Properties portalProperties,
2253                    boolean initPhase, String[] propsValuesStringArray,
2254                    Map<String, StringArraysContainer> stringArraysContainerMap) {
2255    
2256                    for (String key : propsValuesStringArray) {
2257                            String fieldName = StringUtil.replace(
2258                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2259                                    CharPool.UNDERLINE);
2260    
2261                            if (!containsKey(portalProperties, key)) {
2262                                    continue;
2263                            }
2264    
2265                            try {
2266                                    resetPortalPropertiesStringArray(
2267                                            servletContextName, portalProperties, initPhase,
2268                                            propsValuesStringArray, stringArraysContainerMap, key,
2269                                            fieldName);
2270                            }
2271                            catch (Exception e) {
2272                                    _log.error(
2273                                            "Error setting field " + fieldName + ": " + e.getMessage());
2274                            }
2275                    }
2276            }
2277    
2278            protected void resetPortalPropertiesStringArray(
2279                            String servletContextName, Properties portalProperties,
2280                            boolean initPhase, String[] propsValuesStringArray,
2281                            Map<String, StringArraysContainer> stringArraysContainerMap,
2282                            String key, String fieldName)
2283                    throws Exception {
2284    
2285                    Field field = PropsValues.class.getField(fieldName);
2286    
2287                    StringArraysContainer stringArraysContainer =
2288                            stringArraysContainerMap.get(key);
2289    
2290                    String[] value = null;
2291    
2292                    if (initPhase) {
2293                            if (stringArraysContainer
2294                                            instanceof OverrideStringArraysContainer) {
2295    
2296                                    OverrideStringArraysContainer overrideStringArraysContainer =
2297                                            (OverrideStringArraysContainer)stringArraysContainer;
2298    
2299                                    if (overrideStringArraysContainer.isOverridden()) {
2300                                            _log.error("Error setting overridden field " + fieldName);
2301    
2302                                            return;
2303                                    }
2304    
2305                                    value = StringUtil.split(portalProperties.getProperty(key));
2306                            }
2307                            else {
2308                                    value = PropsUtil.getArray(key);
2309                            }
2310                    }
2311    
2312                    stringArraysContainer.setPluginStringArray(servletContextName, value);
2313    
2314                    value = stringArraysContainer.getStringArray();
2315    
2316                    field.set(null, value);
2317            }
2318    
2319            private static final String[] _PROPS_KEYS_EVENTS = {
2320                    LOGIN_EVENTS_POST, LOGIN_EVENTS_PRE, LOGOUT_EVENTS_POST,
2321                    LOGOUT_EVENTS_PRE, SERVLET_SERVICE_EVENTS_POST,
2322                    SERVLET_SERVICE_EVENTS_PRE
2323            };
2324    
2325            private static final String[] _PROPS_KEYS_SESSION_EVENTS = {
2326                    SERVLET_SESSION_CREATE_EVENTS, SERVLET_SESSION_DESTROY_EVENTS
2327            };
2328    
2329            private static final String[] _PROPS_VALUES_BOOLEAN = {
2330                    "auth.forward.by.last.path", "captcha.check.portal.create_account",
2331                    "dl.file.entry.drafts.enabled",
2332                    "dl.file.entry.open.in.ms.office.manual.check.in.required",
2333                    "field.enable.com.liferay.portal.kernel.model.Contact.birthday",
2334                    "field.enable.com.liferay.portal.kernel.model.Contact.male",
2335                    "field.enable.com.liferay.portal.kernel.model.Organization.status",
2336                    "javascript.fast.load", "layout.template.cache.enabled",
2337                    "layout.user.private.layouts.auto.create",
2338                    "layout.user.private.layouts.enabled",
2339                    "layout.user.private.layouts.power.user.required",
2340                    "layout.user.public.layouts.auto.create",
2341                    "layout.user.public.layouts.enabled",
2342                    "layout.user.public.layouts.power.user.required",
2343                    "login.create.account.allow.custom.password", "login.dialog.disabled",
2344                    "my.sites.show.private.sites.with.no.layouts",
2345                    "my.sites.show.public.sites.with.no.layouts",
2346                    "my.sites.show.user.private.sites.with.no.layouts",
2347                    "my.sites.show.user.public.sites.with.no.layouts",
2348                    "portlet.add.default.resource.check.enabled", "rss.feeds.enabled",
2349                    "session.store.password", "social.activity.sets.bundling.enabled",
2350                    "social.activity.sets.enabled", "terms.of.use.required",
2351                    "theme.css.fast.load", "theme.images.fast.load",
2352                    "theme.jsp.override.enabled", "theme.loader.new.theme.id.on.import",
2353                    "theme.portlet.decorate.default", "theme.portlet.sharing.default",
2354                    "user.notification.event.confirmation.enabled",
2355                    "users.email.address.required", "users.image.check.token",
2356                    "users.screen.name.always.autogenerate"
2357            };
2358    
2359            private static final String[] _PROPS_VALUES_INTEGER = {
2360                    "session.max.allowed", "users.image.max.height", "users.image.max.width"
2361            };
2362    
2363            private static final String[] _PROPS_VALUES_LONG = {};
2364    
2365            private static final String[] _PROPS_VALUES_MERGE_STRING_ARRAY = {
2366                    "auth.token.ignore.actions", "auth.token.ignore.origins",
2367                    "auth.token.ignore.portlets", "admin.default.group.names",
2368                    "admin.default.role.names", "admin.default.user.group.names",
2369                    "asset.publisher.display.styles",
2370                    "company.settings.form.authentication",
2371                    "company.settings.form.configuration",
2372                    "company.settings.form.identification",
2373                    "company.settings.form.miscellaneous", "company.settings.form.social",
2374                    "dockbar.add.portlets", "journal.article.form.add",
2375                    "journal.article.form.translate", "journal.article.form.update",
2376                    "layout.form.add", "layout.form.update", "layout.set.form.update",
2377                    "layout.static.portlets.all", "login.form.navigation.post",
2378                    "login.form.navigation.pre", "organizations.form.add.identification",
2379                    "organizations.form.add.main", "organizations.form.add.miscellaneous",
2380                    "portlet.add.default.resource.check.whitelist",
2381                    "portlet.add.default.resource.check.whitelist.actions",
2382                    "portlet.interrupted.request.whitelist",
2383                    "portlet.interrupted.request.whitelist.actions",
2384                    "session.phishing.protected.attributes", "sites.form.add.advanced",
2385                    "sites.form.add.main", "sites.form.add.miscellaneous",
2386                    "sites.form.add.seo", "sites.form.update.advanced",
2387                    "sites.form.update.main", "sites.form.update.miscellaneous",
2388                    "sites.form.update.seo", "users.form.add.identification",
2389                    "users.form.add.main", "users.form.add.miscellaneous",
2390                    "users.form.my.account.identification", "users.form.my.account.main",
2391                    "users.form.my.account.miscellaneous",
2392                    "users.form.update.identification", "users.form.update.main",
2393                    "users.form.update.miscellaneous"
2394            };
2395    
2396            private static final String[] _PROPS_VALUES_OBSOLETE = {
2397                    "layout.user.private.layouts.modifiable",
2398                    "layout.user.public.layouts.modifiable"
2399            };
2400    
2401            private static final String[] _PROPS_VALUES_OVERRIDE_STRING_ARRAY = {
2402                    "locales.beta"
2403            };
2404    
2405            private static final String[] _PROPS_VALUES_STRING = {
2406                    "company.default.locale", "company.default.time.zone",
2407                    "default.landing.page.path", "default.regular.color.scheme.id",
2408                    "default.regular.theme.id", "passwords.passwordpolicytoolkit.generator",
2409                    "passwords.passwordpolicytoolkit.static",
2410                    "phone.number.format.international.regexp",
2411                    "phone.number.format.usa.regexp", "social.activity.sets.selector",
2412                    "theme.shortcut.icon"
2413            };
2414    
2415            private static final String[] _TOKEN_WHITELIST_NAMES = {
2416                    AUTH_TOKEN_IGNORE_ACTIONS, AUTH_TOKEN_IGNORE_ORIGINS,
2417                    AUTH_TOKEN_IGNORE_PORTLETS,
2418                    PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST,
2419                    PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST_ACTIONS
2420            };
2421    
2422            private static final Log _log = LogFactoryUtil.getLog(
2423                    HookHotDeployListener.class);
2424    
2425            private final Map<String, DLFileEntryProcessorContainer>
2426                    _dlFileEntryProcessorContainerMap = new HashMap<>();
2427            private final Map<String, DLRepositoryContainer> _dlRepositoryContainerMap =
2428                    new HashMap<>();
2429            private final Map<String, HotDeployListenersContainer>
2430                    _hotDeployListenersContainerMap = new HashMap<>();
2431            private final Map<String, StringArraysContainer>
2432                    _mergeStringArraysContainerMap = new HashMap<>();
2433            private final Map<String, StringArraysContainer>
2434                    _overrideStringArraysContainerMap = new HashMap<>();
2435            private final Map<String, Properties> _portalPropertiesMap =
2436                    new HashMap<>();
2437            private final Set<String> _propsKeysEvents = SetUtil.fromArray(
2438                    _PROPS_KEYS_EVENTS);
2439            private final Set<String> _propsKeysSessionEvents = SetUtil.fromArray(
2440                    _PROPS_KEYS_SESSION_EVENTS);
2441            private final Map<String, Map<Object, ServiceRegistration<?>>>
2442                    _serviceRegistrations = newMap();
2443            private final Set<String> _servletContextNames = new HashSet<>();
2444    
2445            private static class DLFileEntryProcessorContainer {
2446    
2447                    public void registerDLProcessor(DLProcessor dlProcessor) {
2448                            DLProcessorRegistryUtil.register(dlProcessor);
2449    
2450                            _dlProcessors.add(dlProcessor);
2451                    }
2452    
2453                    public void unregisterDLProcessors() {
2454                            for (DLProcessor dlProcessor : _dlProcessors) {
2455                                    DLProcessorRegistryUtil.unregister(dlProcessor);
2456                            }
2457    
2458                            _dlProcessors.clear();
2459                    }
2460    
2461                    private final List<DLProcessor> _dlProcessors = new ArrayList<>();
2462    
2463            }
2464    
2465            private static class DLRepositoryContainer {
2466    
2467                    public void registerRepositoryFactory(
2468                            String className,
2469                            ExternalRepositoryFactory externalRepositoryFactory) {
2470    
2471                            RepositoryClassDefinitionCatalogUtil.
2472                                    registerLegacyExternalRepositoryFactory(
2473                                            className, externalRepositoryFactory);
2474    
2475                            _classNames.add(className);
2476                    }
2477    
2478                    public void unregisterRepositoryFactories() {
2479                            for (String className : _classNames) {
2480                                    RepositoryClassDefinitionCatalogUtil.
2481                                            unregisterLegacyExternalRepositoryFactory(className);
2482                            }
2483    
2484                            _classNames.clear();
2485                    }
2486    
2487                    private final List<String> _classNames = new ArrayList<>();
2488    
2489            }
2490    
2491            private static class HotDeployListenersContainer {
2492    
2493                    public void registerHotDeployListener(
2494                            HotDeployListener hotDeployListener) {
2495    
2496                            HotDeployUtil.registerListener(hotDeployListener);
2497    
2498                            _hotDeployListeners.add(hotDeployListener);
2499                    }
2500    
2501                    public void unregisterHotDeployListeners() {
2502                            for (HotDeployListener hotDeployListener : _hotDeployListeners) {
2503                                    HotDeployUtil.unregisterListener(hotDeployListener);
2504                            }
2505                    }
2506    
2507                    private final List<HotDeployListener> _hotDeployListeners =
2508                            new ArrayList<>();
2509    
2510            }
2511    
2512            private static class MergeStringArraysContainer
2513                    implements StringArraysContainer {
2514    
2515                    @Override
2516                    public String[] getStringArray() {
2517                            Set<String> mergedStringSet = new LinkedHashSet<>();
2518    
2519                            mergedStringSet.addAll(Arrays.asList(_portalStringArray));
2520    
2521                            for (Map.Entry<String, String[]> entry :
2522                                            _pluginStringArrayMap.entrySet()) {
2523    
2524                                    mergedStringSet.addAll(Arrays.asList(entry.getValue()));
2525                            }
2526    
2527                            return mergedStringSet.toArray(new String[mergedStringSet.size()]);
2528                    }
2529    
2530                    @Override
2531                    public void setPluginStringArray(
2532                            String servletContextName, String[] pluginStringArray) {
2533    
2534                            if (pluginStringArray != null) {
2535                                    _pluginStringArrayMap.put(
2536                                            servletContextName, pluginStringArray);
2537                            }
2538                            else {
2539                                    _pluginStringArrayMap.remove(servletContextName);
2540                            }
2541                    }
2542    
2543                    private MergeStringArraysContainer(String key) {
2544                            _portalStringArray = PropsUtil.getArray(key);
2545                    }
2546    
2547                    private final Map<String, String[]> _pluginStringArrayMap =
2548                            new HashMap<>();
2549                    private String[] _portalStringArray;
2550    
2551            }
2552    
2553            private static class OverrideStringArraysContainer
2554                    implements StringArraysContainer {
2555    
2556                    @Override
2557                    public String[] getStringArray() {
2558                            if (_pluginStringArray != null) {
2559                                    return _pluginStringArray;
2560                            }
2561    
2562                            return _portalStringArray;
2563                    }
2564    
2565                    public boolean isOverridden() {
2566                            if (Validator.isNotNull(_servletContextName)) {
2567                                    return true;
2568                            }
2569                            else {
2570                                    return false;
2571                            }
2572                    }
2573    
2574                    @Override
2575                    public void setPluginStringArray(
2576                            String servletContextName, String[] pluginStringArray) {
2577    
2578                            if (pluginStringArray != null) {
2579                                    if (!isOverridden()) {
2580                                            _servletContextName = servletContextName;
2581                                            _pluginStringArray = pluginStringArray;
2582                                    }
2583                            }
2584                            else {
2585                                    if (_servletContextName.equals(servletContextName)) {
2586                                            _servletContextName = null;
2587                                            _pluginStringArray = null;
2588                                    }
2589                            }
2590                    }
2591    
2592                    private OverrideStringArraysContainer(String key) {
2593                            _portalStringArray = PropsUtil.getArray(key);
2594                    }
2595    
2596                    private String[] _pluginStringArray;
2597                    private String[] _portalStringArray;
2598                    private String _servletContextName;
2599    
2600            }
2601    
2602            private interface StringArraysContainer {
2603    
2604                    public String[] getStringArray();
2605    
2606                    public void setPluginStringArray(
2607                            String servletContextName, String[] pluginStringArray);
2608    
2609            }
2610    
2611    }