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