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.portal.captcha.CaptchaImpl;
018    import com.liferay.portal.kernel.bean.BeanLocatorException;
019    import com.liferay.portal.kernel.bean.ClassLoaderBeanHandler;
020    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
021    import com.liferay.portal.kernel.bean.PortletBeanLocatorUtil;
022    import com.liferay.portal.kernel.captcha.Captcha;
023    import com.liferay.portal.kernel.captcha.CaptchaUtil;
024    import com.liferay.portal.kernel.configuration.Configuration;
025    import com.liferay.portal.kernel.configuration.ConfigurationFactoryUtil;
026    import com.liferay.portal.kernel.deploy.DeployManagerUtil;
027    import com.liferay.portal.kernel.deploy.auto.AutoDeployListener;
028    import com.liferay.portal.kernel.deploy.hot.BaseHotDeployListener;
029    import com.liferay.portal.kernel.deploy.hot.HotDeployEvent;
030    import com.liferay.portal.kernel.deploy.hot.HotDeployException;
031    import com.liferay.portal.kernel.deploy.hot.HotDeployListener;
032    import com.liferay.portal.kernel.deploy.hot.HotDeployUtil;
033    import com.liferay.portal.kernel.events.Action;
034    import com.liferay.portal.kernel.events.InvokerAction;
035    import com.liferay.portal.kernel.events.InvokerSessionAction;
036    import com.liferay.portal.kernel.events.InvokerSimpleAction;
037    import com.liferay.portal.kernel.events.LifecycleAction;
038    import com.liferay.portal.kernel.events.SessionAction;
039    import com.liferay.portal.kernel.events.SimpleAction;
040    import com.liferay.portal.kernel.format.PhoneNumberFormat;
041    import com.liferay.portal.kernel.language.LanguageUtil;
042    import com.liferay.portal.kernel.lock.LockListener;
043    import com.liferay.portal.kernel.log.Log;
044    import com.liferay.portal.kernel.log.LogFactoryUtil;
045    import com.liferay.portal.kernel.plugin.PluginPackage;
046    import com.liferay.portal.kernel.sanitizer.Sanitizer;
047    import com.liferay.portal.kernel.search.IndexerPostProcessor;
048    import com.liferay.portal.kernel.security.auth.verifier.AuthVerifier;
049    import com.liferay.portal.kernel.security.auto.login.AutoLogin;
050    import com.liferay.portal.kernel.security.pacl.PACLConstants;
051    import com.liferay.portal.kernel.security.pacl.permission.PortalHookPermission;
052    import com.liferay.portal.kernel.servlet.DirectServletRegistryUtil;
053    import com.liferay.portal.kernel.servlet.LiferayFilter;
054    import com.liferay.portal.kernel.servlet.LiferayFilterTracker;
055    import com.liferay.portal.kernel.servlet.TryFilter;
056    import com.liferay.portal.kernel.servlet.TryFinallyFilter;
057    import com.liferay.portal.kernel.servlet.WrapHttpServletRequestFilter;
058    import com.liferay.portal.kernel.servlet.WrapHttpServletResponseFilter;
059    import com.liferay.portal.kernel.servlet.taglib.ui.FormNavigatorConstants;
060    import com.liferay.portal.kernel.servlet.taglib.ui.FormNavigatorEntry;
061    import com.liferay.portal.kernel.struts.StrutsAction;
062    import com.liferay.portal.kernel.struts.StrutsPortletAction;
063    import com.liferay.portal.kernel.upgrade.UpgradeProcess;
064    import com.liferay.portal.kernel.upgrade.util.UpgradeProcessUtil;
065    import com.liferay.portal.kernel.url.ServletContextURLContainer;
066    import com.liferay.portal.kernel.util.CharPool;
067    import com.liferay.portal.kernel.util.GetterUtil;
068    import com.liferay.portal.kernel.util.HttpUtil;
069    import com.liferay.portal.kernel.util.InstanceFactory;
070    import com.liferay.portal.kernel.util.LocaleUtil;
071    import com.liferay.portal.kernel.util.PropertiesUtil;
072    import com.liferay.portal.kernel.util.PropsKeys;
073    import com.liferay.portal.kernel.util.ProxyUtil;
074    import com.liferay.portal.kernel.util.ReflectionUtil;
075    import com.liferay.portal.kernel.util.SetUtil;
076    import com.liferay.portal.kernel.util.StringPool;
077    import com.liferay.portal.kernel.util.StringUtil;
078    import com.liferay.portal.kernel.util.Tuple;
079    import com.liferay.portal.kernel.util.Validator;
080    import com.liferay.portal.kernel.xml.Document;
081    import com.liferay.portal.kernel.xml.Element;
082    import com.liferay.portal.kernel.xml.UnsecureSAXReaderUtil;
083    import com.liferay.portal.language.LiferayResourceBundle;
084    import com.liferay.portal.model.ModelListener;
085    import com.liferay.portal.repository.registry.RepositoryClassDefinitionCatalogUtil;
086    import com.liferay.portal.repository.util.ExternalRepositoryFactory;
087    import com.liferay.portal.repository.util.ExternalRepositoryFactoryImpl;
088    import com.liferay.portal.security.auth.AuthFailure;
089    import com.liferay.portal.security.auth.AuthToken;
090    import com.liferay.portal.security.auth.AuthTokenWhitelistUtil;
091    import com.liferay.portal.security.auth.AuthVerifierPipeline;
092    import com.liferay.portal.security.auth.Authenticator;
093    import com.liferay.portal.security.auth.CompanyThreadLocal;
094    import com.liferay.portal.security.auth.EmailAddressGenerator;
095    import com.liferay.portal.security.auth.EmailAddressValidator;
096    import com.liferay.portal.security.auth.FullNameGenerator;
097    import com.liferay.portal.security.auth.FullNameValidator;
098    import com.liferay.portal.security.auth.InterruptedPortletRequestWhitelistUtil;
099    import com.liferay.portal.security.auth.ScreenNameGenerator;
100    import com.liferay.portal.security.auth.ScreenNameValidator;
101    import com.liferay.portal.security.lang.DoPrivilegedBean;
102    import com.liferay.portal.security.ldap.AttributesTransformer;
103    import com.liferay.portal.security.membershippolicy.OrganizationMembershipPolicy;
104    import com.liferay.portal.security.membershippolicy.RoleMembershipPolicy;
105    import com.liferay.portal.security.membershippolicy.SiteMembershipPolicy;
106    import com.liferay.portal.security.membershippolicy.UserGroupMembershipPolicy;
107    import com.liferay.portal.security.pwd.Toolkit;
108    import com.liferay.portal.service.ReleaseLocalServiceUtil;
109    import com.liferay.portal.service.ServiceWrapper;
110    import com.liferay.portal.service.persistence.BasePersistence;
111    import com.liferay.portal.servlet.filters.cache.CacheUtil;
112    import com.liferay.portal.servlet.taglib.ui.DeprecatedFormNavigatorEntry;
113    import com.liferay.portal.spring.aop.ServiceBeanAopProxy;
114    import com.liferay.portal.spring.context.PortalContextLoaderListener;
115    import com.liferay.portal.util.JavaScriptBundleUtil;
116    import com.liferay.portal.util.PortalInstances;
117    import com.liferay.portal.util.PropsUtil;
118    import com.liferay.portal.util.PropsValues;
119    import com.liferay.portlet.ControlPanelEntry;
120    import com.liferay.portlet.documentlibrary.antivirus.AntivirusScanner;
121    import com.liferay.portlet.documentlibrary.antivirus.AntivirusScannerUtil;
122    import com.liferay.portlet.documentlibrary.antivirus.AntivirusScannerWrapper;
123    import com.liferay.portlet.documentlibrary.store.StoreFactory;
124    import com.liferay.portlet.documentlibrary.util.DLProcessor;
125    import com.liferay.portlet.documentlibrary.util.DLProcessorRegistryUtil;
126    import com.liferay.registry.Registry;
127    import com.liferay.registry.RegistryUtil;
128    import com.liferay.registry.ServiceRegistration;
129    import com.liferay.taglib.FileAvailabilityUtil;
130    
131    import java.io.InputStream;
132    
133    import java.lang.reflect.Constructor;
134    import java.lang.reflect.Field;
135    
136    import java.net.URL;
137    
138    import java.util.ArrayList;
139    import java.util.Arrays;
140    import java.util.HashMap;
141    import java.util.HashSet;
142    import java.util.Iterator;
143    import java.util.LinkedHashSet;
144    import java.util.List;
145    import java.util.Locale;
146    import java.util.Map;
147    import java.util.Properties;
148    import java.util.ResourceBundle;
149    import java.util.Set;
150    import java.util.concurrent.ConcurrentHashMap;
151    
152    import javax.servlet.Filter;
153    import javax.servlet.ServletContext;
154    
155    import org.springframework.aop.TargetSource;
156    import org.springframework.aop.framework.AdvisedSupport;
157    
158    /**
159     * @author Brian Wing Shun Chan
160     * @author Bruno Farache
161     * @author Wesley Gong
162     * @author Ryan Park
163     * @author Mika Koivisto
164     * @author Peter Fellwock
165     * @author Raymond Aug??
166     * @author Kamesh Sampath
167     */
168    public class HookHotDeployListener
169            extends BaseHotDeployListener implements PropsKeys {
170    
171            public static final String[] SUPPORTED_PROPERTIES = {
172                    "admin.default.group.names", "admin.default.role.names",
173                    "admin.default.user.group.names",
174                    "asset.publisher.asset.entry.query.processors",
175                    "asset.publisher.display.styles",
176                    "asset.publisher.query.form.configuration", "auth.forward.by.last.path",
177                    "auth.public.paths", "auth.verifier.pipeline", "auto.deploy.listeners",
178                    "application.startup.events", "auth.failure", "auth.max.failures",
179                    "auth.token.ignore.actions", "auth.token.ignore.origins",
180                    "auth.token.ignore.portlets", "auth.token.impl", "auth.pipeline.post",
181                    "auth.pipeline.pre", "auto.login.hooks",
182                    "captcha.check.portal.create_account", "captcha.engine.impl",
183                    "company.default.locale", "company.default.time.zone",
184                    "company.settings.form.authentication",
185                    "company.settings.form.configuration",
186                    "company.settings.form.identification",
187                    "company.settings.form.miscellaneous", "company.settings.form.social",
188                    "control.panel.entry.class.default", "default.landing.page.path",
189                    "default.regular.color.scheme.id", "default.regular.theme.id",
190                    "default.wap.color.scheme.id", "default.wap.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.model.Contact.birthday",
196                    "field.enable.com.liferay.portal.model.Contact.male",
197                    "field.enable.com.liferay.portal.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());
733                    }
734            }
735    
736            protected void initAuthTokenWhiteListActions(
737                            String servletContextName, Properties portalProperties)
738                    throws Exception {
739    
740                    String[] authTokenIgnoreActions = StringUtil.split(
741                            portalProperties.getProperty(AUTH_TOKEN_IGNORE_ACTIONS));
742    
743                    for (String authTokenIgnoreAction : authTokenIgnoreActions) {
744                            registerService(
745                                    servletContextName,
746                                    AUTH_TOKEN_IGNORE_ACTIONS + authTokenIgnoreAction, Object.class,
747                                    new Object());
748                    }
749            }
750    
751            protected void initAuthVerifiers(
752                            String servletContextName, ClassLoader portletClassLoader,
753                            Properties portalProperties)
754                    throws Exception {
755    
756                    String[] authVerifierClassNames = StringUtil.split(
757                            portalProperties.getProperty(AUTH_VERIFIER_PIPELINE));
758    
759                    for (String authVerifierClassName : authVerifierClassNames) {
760                            AuthVerifier authVerifier = (AuthVerifier)newInstance(
761                                    portletClassLoader, AuthVerifier.class, authVerifierClassName);
762    
763                            Properties properties = PropertiesUtil.getProperties(
764                                    portalProperties,
765                                    AuthVerifierPipeline.getAuthVerifierPropertyName(
766                                            authVerifierClassName),
767                                    true);
768    
769                            registerService(
770                                    servletContextName, authVerifierClassName, AuthVerifier.class,
771                                    authVerifier, properties);
772                    }
773            }
774    
775            protected void initAutoDeployListeners(
776                            String servletContextName, ClassLoader portletClassLoader,
777                            Properties portalProperties)
778                    throws Exception {
779    
780                    String[] autoDeployListenerClassNames = StringUtil.split(
781                            portalProperties.getProperty(PropsKeys.AUTO_DEPLOY_LISTENERS));
782    
783                    if (autoDeployListenerClassNames.length == 0) {
784                            return;
785                    }
786    
787                    for (String autoDeployListenerClassName :
788                                    autoDeployListenerClassNames) {
789    
790                            AutoDeployListener autoDeployListener =
791                                    (AutoDeployListener)newInstance(
792                                            portletClassLoader, AutoDeployListener.class,
793                                            autoDeployListenerClassName);
794    
795                            registerService(
796                                    servletContextName, autoDeployListenerClassName,
797                                    AutoDeployListener.class, autoDeployListener);
798                    }
799            }
800    
801            protected void initAutoLogins(
802                            String servletContextName, ClassLoader portletClassLoader,
803                            Properties portalProperties)
804                    throws Exception {
805    
806                    String[] autoLoginClassNames = StringUtil.split(
807                            portalProperties.getProperty(AUTO_LOGIN_HOOKS));
808    
809                    for (String autoLoginClassName : autoLoginClassNames) {
810                            AutoLogin autoLogin = (AutoLogin)newInstance(
811                                    portletClassLoader, AutoLogin.class, autoLoginClassName);
812    
813                            registerService(
814                                    servletContextName, autoLoginClassName, AutoLogin.class,
815                                    autoLogin);
816                    }
817            }
818    
819            protected void initCustomJspDir(
820                            ServletContext servletContext, String servletContextName,
821                            ClassLoader portletClassLoader, PluginPackage pluginPackage,
822                            Element rootElement)
823                    throws Exception {
824    
825                    String customJspDir = rootElement.elementText("custom-jsp-dir");
826    
827                    if (Validator.isNull(customJspDir)) {
828                            return;
829                    }
830    
831                    if (!checkPermission(
832                                    PACLConstants.PORTAL_HOOK_PERMISSION_CUSTOM_JSP_DIR,
833                                    portletClassLoader, null, "Rejecting custom JSP directory")) {
834    
835                            return;
836                    }
837    
838                    if (_log.isDebugEnabled()) {
839                            _log.debug("Custom JSP directory: " + customJspDir);
840                    }
841    
842                    boolean customJspGlobal = GetterUtil.getBoolean(
843                            rootElement.elementText("custom-jsp-global"), true);
844    
845                    CustomJspBag customJspBag = new CustomJspBagImpl(
846                            new ServletContextURLContainer(servletContext), customJspDir,
847                            customJspGlobal);
848    
849                    registerService(
850                            servletContextName, "customJsp", CustomJspBag.class, customJspBag,
851                            "context.id", servletContextName, "context.name",
852                            pluginPackage.getName());
853            }
854    
855            protected void initEvent(
856                            String servletContextName, ClassLoader portletClassLoader,
857                            String eventName, String eventClassName)
858                    throws Exception {
859    
860                    if (eventName.equals(APPLICATION_STARTUP_EVENTS)) {
861                            Class<?> clazz = portletClassLoader.loadClass(eventClassName);
862    
863                            SimpleAction simpleAction = (SimpleAction)clazz.newInstance();
864    
865                            simpleAction = new InvokerSimpleAction(
866                                    simpleAction, portletClassLoader);
867    
868                            Long companyId = CompanyThreadLocal.getCompanyId();
869    
870                            try {
871                                    long[] companyIds = PortalInstances.getCompanyIds();
872    
873                                    for (long curCompanyId : companyIds) {
874                                            CompanyThreadLocal.setCompanyId(curCompanyId);
875    
876                                            simpleAction.run(
877                                                    new String[] {String.valueOf(curCompanyId)});
878                                    }
879                            }
880                            finally {
881                                    CompanyThreadLocal.setCompanyId(companyId);
882                            }
883                    }
884    
885                    if (_propsKeysEvents.contains(eventName)) {
886                            Class<?> clazz = portletClassLoader.loadClass(eventClassName);
887    
888                            Action action = (Action)clazz.newInstance();
889    
890                            action = new InvokerAction(action, portletClassLoader);
891    
892                            registerService(
893                                    servletContextName, eventClassName, LifecycleAction.class,
894                                    action, "key", eventName);
895                    }
896    
897                    if (_propsKeysSessionEvents.contains(eventName)) {
898                            Class<?> clazz = portletClassLoader.loadClass(eventClassName);
899    
900                            SessionAction sessionAction = (SessionAction)clazz.newInstance();
901    
902                            sessionAction = new InvokerSessionAction(
903                                    sessionAction, portletClassLoader);
904    
905                            registerService(
906                                    servletContextName, eventClassName, LifecycleAction.class,
907                                    sessionAction, "key", eventName);
908                    }
909            }
910    
911            protected void initEvents(
912                            String servletContextName, ClassLoader portletClassLoader,
913                            Properties portalProperties)
914                    throws Exception {
915    
916                    for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
917                            String key = (String)entry.getKey();
918    
919                            if (!key.equals(APPLICATION_STARTUP_EVENTS) &&
920                                    !_propsKeysEvents.contains(key) &&
921                                    !_propsKeysSessionEvents.contains(key)) {
922    
923                                    continue;
924                            }
925    
926                            String eventName = key;
927                            String[] eventClassNames = StringUtil.split(
928                                    (String)entry.getValue());
929    
930                            for (String eventClassName : eventClassNames) {
931                                    initEvent(
932                                            servletContextName, portletClassLoader, eventName,
933                                            eventClassName);
934                            }
935                    }
936            }
937    
938            protected void initFormNavigatorEntries(
939                            String servletContextName, Properties portalProperties)
940                    throws Exception {
941    
942                    initFormNavigatorEntry(
943                            servletContextName, portalProperties,
944                            COMPANY_SETTINGS_FORM_CONFIGURATION,
945                            FormNavigatorConstants.CATEGORY_KEY_COMPANY_SETTINGS_CONFIGURATION,
946                            FormNavigatorConstants.FORM_NAVIGATOR_ID_COMPANY_SETTINGS,
947                            "portal_settings");
948                    initFormNavigatorEntry(
949                            servletContextName, portalProperties,
950                            COMPANY_SETTINGS_FORM_IDENTIFICATION,
951                            FormNavigatorConstants.CATEGORY_KEY_COMPANY_SETTINGS_IDENTIFICATION,
952                            FormNavigatorConstants.FORM_NAVIGATOR_ID_COMPANY_SETTINGS,
953                            "portal_settings");
954                    initFormNavigatorEntry(
955                            servletContextName, portalProperties,
956                            COMPANY_SETTINGS_FORM_MISCELLANEOUS,
957                            FormNavigatorConstants.CATEGORY_KEY_COMPANY_SETTINGS_MISCELLANEOUS,
958                            FormNavigatorConstants.FORM_NAVIGATOR_ID_COMPANY_SETTINGS,
959                            "portal_settings");
960                    initFormNavigatorEntry(
961                            servletContextName, portalProperties, COMPANY_SETTINGS_FORM_SOCIAL,
962                            FormNavigatorConstants.CATEGORY_KEY_COMPANY_SETTINGS_SOCIAL,
963                            FormNavigatorConstants.FORM_NAVIGATOR_ID_COMPANY_SETTINGS,
964                            "portal_settings");
965    
966                    initFormNavigatorEntry(
967                            servletContextName, portalProperties, LAYOUT_FORM_ADD,
968                            StringPool.BLANK, FormNavigatorConstants.FORM_NAVIGATOR_ID_LAYOUT,
969                            "layouts_admin/layout");
970                    initFormNavigatorEntry(
971                            servletContextName, portalProperties, LAYOUT_FORM_UPDATE,
972                            StringPool.BLANK, FormNavigatorConstants.FORM_NAVIGATOR_ID_LAYOUT,
973                            "layouts_admin/layout");
974    
975                    initFormNavigatorEntry(
976                            servletContextName, portalProperties, LAYOUT_SET_FORM_UPDATE,
977                            StringPool.BLANK,
978                            FormNavigatorConstants.FORM_NAVIGATOR_ID_LAYOUT_SET,
979                            "layouts_admin/layout_set");
980    
981                    initFormNavigatorEntry(
982                            servletContextName, portalProperties,
983                            ORGANIZATIONS_FORM_ADD_IDENTIFICATION,
984                            FormNavigatorConstants.CATEGORY_KEY_ORGANIZATION_IDENTIFICATION,
985                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
986                            "users_admin/organization");
987                    initFormNavigatorEntry(
988                            servletContextName, portalProperties, ORGANIZATIONS_FORM_ADD_MAIN,
989                            FormNavigatorConstants.
990                                    CATEGORY_KEY_ORGANIZATION_ORGANIZATION_INFORMATION,
991                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
992                            "users_admin/organization");
993                    initFormNavigatorEntry(
994                            servletContextName, portalProperties,
995                            ORGANIZATIONS_FORM_ADD_MISCELLANEOUS,
996                            FormNavigatorConstants.CATEGORY_KEY_ORGANIZATION_MISCELLANEOUS,
997                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
998                            "users_admin/organization");
999                    initFormNavigatorEntry(
1000                            servletContextName, portalProperties,
1001                            ORGANIZATIONS_FORM_UPDATE_IDENTIFICATION,
1002                            FormNavigatorConstants.CATEGORY_KEY_ORGANIZATION_IDENTIFICATION,
1003                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
1004                            "users_admin/organization");
1005                    initFormNavigatorEntry(
1006                            servletContextName, portalProperties,
1007                            ORGANIZATIONS_FORM_UPDATE_MAIN,
1008                            FormNavigatorConstants.
1009                                    CATEGORY_KEY_ORGANIZATION_ORGANIZATION_INFORMATION,
1010                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
1011                            "users_admin/organization");
1012                    initFormNavigatorEntry(
1013                            servletContextName, portalProperties,
1014                            ORGANIZATIONS_FORM_UPDATE_MISCELLANEOUS,
1015                            FormNavigatorConstants.CATEGORY_KEY_ORGANIZATION_MISCELLANEOUS,
1016                            FormNavigatorConstants.FORM_NAVIGATOR_ID_ORGANIZATIONS,
1017                            "users_admin/organization");
1018    
1019                    initFormNavigatorEntry(
1020                            servletContextName, portalProperties, SITES_FORM_ADD_ADVANCED,
1021                            FormNavigatorConstants.CATEGORY_KEY_SITES_ADVANCED,
1022                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1023                    initFormNavigatorEntry(
1024                            servletContextName, portalProperties, SITES_FORM_ADD_MAIN,
1025                            FormNavigatorConstants.CATEGORY_KEY_SITES_BASIC_INFORMATION,
1026                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1027                    initFormNavigatorEntry(
1028                            servletContextName, portalProperties, SITES_FORM_ADD_MISCELLANEOUS,
1029                            FormNavigatorConstants.CATEGORY_KEY_SITES_MISCELLANEOUS,
1030                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1031                    initFormNavigatorEntry(
1032                            servletContextName, portalProperties, SITES_FORM_ADD_SEO,
1033                            FormNavigatorConstants.CATEGORY_KEY_SITES_SEO,
1034                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1035                    initFormNavigatorEntry(
1036                            servletContextName, portalProperties, SITES_FORM_UPDATE_ADVANCED,
1037                            FormNavigatorConstants.CATEGORY_KEY_SITES_ADVANCED,
1038                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1039                    initFormNavigatorEntry(
1040                            servletContextName, portalProperties, SITES_FORM_UPDATE_MAIN,
1041                            FormNavigatorConstants.CATEGORY_KEY_SITES_BASIC_INFORMATION,
1042                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1043                    initFormNavigatorEntry(
1044                            servletContextName, portalProperties,
1045                            SITES_FORM_UPDATE_MISCELLANEOUS,
1046                            FormNavigatorConstants.CATEGORY_KEY_SITES_MISCELLANEOUS,
1047                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1048                    initFormNavigatorEntry(
1049                            servletContextName, portalProperties, SITES_FORM_UPDATE_SEO,
1050                            FormNavigatorConstants.CATEGORY_KEY_SITES_SEO,
1051                            FormNavigatorConstants.FORM_NAVIGATOR_ID_SITES, "sites_admin/site");
1052    
1053                    initFormNavigatorEntry(
1054                            servletContextName, portalProperties, USERS_FORM_ADD_IDENTIFICATION,
1055                            FormNavigatorConstants.CATEGORY_KEY_USER_IDENTIFICATION,
1056                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1057                    initFormNavigatorEntry(
1058                            servletContextName, portalProperties, USERS_FORM_ADD_MAIN,
1059                            FormNavigatorConstants.CATEGORY_KEY_USER_USER_INFORMATION,
1060                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1061                    initFormNavigatorEntry(
1062                            servletContextName, portalProperties, USERS_FORM_ADD_MISCELLANEOUS,
1063                            FormNavigatorConstants.CATEGORY_KEY_USER_MISCELLANEOUS,
1064                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1065                    initFormNavigatorEntry(
1066                            servletContextName, portalProperties,
1067                            USERS_FORM_MY_ACCOUNT_IDENTIFICATION,
1068                            FormNavigatorConstants.CATEGORY_KEY_USER_IDENTIFICATION,
1069                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1070                    initFormNavigatorEntry(
1071                            servletContextName, portalProperties, USERS_FORM_MY_ACCOUNT_MAIN,
1072                            FormNavigatorConstants.CATEGORY_KEY_USER_USER_INFORMATION,
1073                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1074                    initFormNavigatorEntry(
1075                            servletContextName, portalProperties,
1076                            USERS_FORM_MY_ACCOUNT_MISCELLANEOUS,
1077                            FormNavigatorConstants.CATEGORY_KEY_USER_MISCELLANEOUS,
1078                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1079                    initFormNavigatorEntry(
1080                            servletContextName, portalProperties,
1081                            USERS_FORM_UPDATE_IDENTIFICATION,
1082                            FormNavigatorConstants.CATEGORY_KEY_USER_IDENTIFICATION,
1083                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1084                    initFormNavigatorEntry(
1085                            servletContextName, portalProperties, USERS_FORM_UPDATE_MAIN,
1086                            FormNavigatorConstants.CATEGORY_KEY_USER_USER_INFORMATION,
1087                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1088                    initFormNavigatorEntry(
1089                            servletContextName, portalProperties,
1090                            USERS_FORM_UPDATE_MISCELLANEOUS,
1091                            FormNavigatorConstants.CATEGORY_KEY_USER_MISCELLANEOUS,
1092                            FormNavigatorConstants.FORM_NAVIGATOR_ID_USERS, "users_admin/user");
1093            }
1094    
1095            protected void initFormNavigatorEntry(
1096                    String servletContextName, Properties portalProperties,
1097                    String portalPropertiesKey, String categoryKey, String formNavigatorId,
1098                    String jspPath) {
1099    
1100                    String[] formNavigatorSections = StringUtil.split(
1101                            portalProperties.getProperty(portalPropertiesKey));
1102    
1103                    for (int i = 0; i < formNavigatorSections.length; i++) {
1104                            String formNavigatorSection = formNavigatorSections[i];
1105    
1106                            FormNavigatorEntry<Object> deprecatedFormNavigatorEntry =
1107                                    new DeprecatedFormNavigatorEntry(
1108                                            formNavigatorSection, formNavigatorSection, categoryKey,
1109                                            formNavigatorId,
1110                                            "/html/portlet/" + jspPath + "/" + formNavigatorSection +
1111                                                    ".jsp");
1112    
1113                            registerService(
1114                                    servletContextName,
1115                                    formNavigatorId + categoryKey + formNavigatorSection,
1116                                    FormNavigatorEntry.class, deprecatedFormNavigatorEntry,
1117                                    "service.ranking", -i);
1118                    }
1119            }
1120    
1121            protected void initHotDeployListeners(
1122                            String servletContextName, ClassLoader portletClassLoader,
1123                            Properties portalProperties)
1124                    throws Exception {
1125    
1126                    String[] hotDeployListenerClassNames = StringUtil.split(
1127                            portalProperties.getProperty(PropsKeys.HOT_DEPLOY_LISTENERS));
1128    
1129                    if (hotDeployListenerClassNames.length == 0) {
1130                            return;
1131                    }
1132    
1133                    HotDeployListenersContainer hotDeployListenersContainer =
1134                            new HotDeployListenersContainer();
1135    
1136                    _hotDeployListenersContainerMap.put(
1137                            servletContextName, hotDeployListenersContainer);
1138    
1139                    for (String hotDeployListenerClassName : hotDeployListenerClassNames) {
1140                            HotDeployListener hotDeployListener =
1141                                    (HotDeployListener)newInstance(
1142                                            portletClassLoader, HotDeployListener.class,
1143                                            hotDeployListenerClassName);
1144    
1145                            hotDeployListenersContainer.registerHotDeployListener(
1146                                    hotDeployListener);
1147                    }
1148            }
1149    
1150            protected void initIndexerPostProcessors(
1151                            String servletContextName, ClassLoader portletClassLoader,
1152                            Element parentElement)
1153                    throws Exception {
1154    
1155                    List<Element> indexerPostProcessorElements = parentElement.elements(
1156                            "indexer-post-processor");
1157    
1158                    for (Element indexerPostProcessorElement :
1159                                    indexerPostProcessorElements) {
1160    
1161                            String indexerClassName = indexerPostProcessorElement.elementText(
1162                                    "indexer-class-name");
1163    
1164                            if (!checkPermission(
1165                                            PACLConstants.PORTAL_HOOK_PERMISSION_INDEXER,
1166                                            portletClassLoader, indexerClassName,
1167                                            "Rejecting indexer " + indexerClassName)) {
1168    
1169                                    continue;
1170                            }
1171    
1172                            String indexerPostProcessorImpl =
1173                                    indexerPostProcessorElement.elementText(
1174                                            "indexer-post-processor-impl");
1175    
1176                            IndexerPostProcessor indexerPostProcessor =
1177                                    (IndexerPostProcessor)InstanceFactory.newInstance(
1178                                            portletClassLoader, indexerPostProcessorImpl);
1179    
1180                            registerService(
1181                                    servletContextName, indexerPostProcessorImpl,
1182                                    IndexerPostProcessor.class, indexerPostProcessor,
1183                                    "indexer.class.name", indexerClassName);
1184                    }
1185            }
1186    
1187            protected void initLanguageProperties(
1188                            String servletContextName, ClassLoader portletClassLoader,
1189                            Element parentElement)
1190                    throws Exception {
1191    
1192                    List<Element> languagePropertiesElements = parentElement.elements(
1193                            "language-properties");
1194    
1195                    String baseLanguagePropertiesLocation = null;
1196                    URL baseLanguageURL = null;
1197    
1198                    for (Element languagePropertiesElement : languagePropertiesElements) {
1199                            String languagePropertiesLocation =
1200                                    languagePropertiesElement.getText();
1201    
1202                            Locale locale = getLocale(languagePropertiesLocation);
1203    
1204                            if (locale != null) {
1205                                    if (!checkPermission(
1206                                                    PACLConstants.
1207                                                            PORTAL_HOOK_PERMISSION_LANGUAGE_PROPERTIES_LOCALE,
1208                                                    portletClassLoader, locale,
1209                                                    "Rejecting locale " + locale)) {
1210    
1211                                            continue;
1212                                    }
1213                            }
1214    
1215                            URL url = portletClassLoader.getResource(
1216                                    languagePropertiesLocation);
1217    
1218                            if (url == null) {
1219                                    continue;
1220                            }
1221    
1222                            if (locale != null) {
1223                                    String languageId = LocaleUtil.toLanguageId(locale);
1224    
1225                                    try (InputStream inputStream = url.openStream()) {
1226                                            ResourceBundle resourceBundle = new LiferayResourceBundle(
1227                                                    inputStream, StringPool.UTF8);
1228    
1229                                            Map<String, Object> properties = new HashMap<>();
1230    
1231                                            properties.put("language.id", languageId);
1232    
1233                                            registerService(
1234                                                    servletContextName, languagePropertiesLocation,
1235                                                    ResourceBundle.class, resourceBundle, properties);
1236                                    }
1237                            }
1238                            else {
1239                                    baseLanguagePropertiesLocation = languagePropertiesLocation;
1240                                    baseLanguageURL = url;
1241                            }
1242                    }
1243    
1244                    if (baseLanguageURL != null) {
1245                            Locale locale = new Locale(StringPool.BLANK);
1246    
1247                            String languageId = LocaleUtil.toLanguageId(locale);
1248    
1249                            try (InputStream inputStream = baseLanguageURL.openStream()) {
1250                                    ResourceBundle resourceBundle = new LiferayResourceBundle(
1251                                            inputStream, StringPool.UTF8);
1252    
1253                                    Map<String, Object> properties = new HashMap<>();
1254    
1255                                    properties.put("language.id", languageId);
1256    
1257                                    registerService(
1258                                            servletContextName, baseLanguagePropertiesLocation,
1259                                            ResourceBundle.class, resourceBundle, properties);
1260                            }
1261                    }
1262            }
1263    
1264            protected void initModelListener(
1265                            String servletContextName, ClassLoader portletClassLoader,
1266                            String modelName, String modelListenerClassName)
1267                    throws Exception {
1268    
1269                    ModelListener<?> modelListener = (ModelListener<?>)newInstance(
1270                            portletClassLoader, ModelListener.class, modelListenerClassName);
1271    
1272                    registerService(
1273                            servletContextName, modelListenerClassName, ModelListener.class,
1274                            modelListener);
1275            }
1276    
1277            protected void initModelListeners(
1278                            String servletContextName, ClassLoader portletClassLoader,
1279                            Properties portalProperties)
1280                    throws Exception {
1281    
1282                    for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
1283                            String key = (String)entry.getKey();
1284    
1285                            if (!key.startsWith(VALUE_OBJECT_LISTENER)) {
1286                                    continue;
1287                            }
1288    
1289                            String modelName = key.substring(VALUE_OBJECT_LISTENER.length());
1290    
1291                            String[] modelListenerClassNames = StringUtil.split(
1292                                    (String)entry.getValue());
1293    
1294                            for (String modelListenerClassName : modelListenerClassNames) {
1295                                    initModelListener(
1296                                            servletContextName, portletClassLoader, modelName,
1297                                            modelListenerClassName);
1298                            }
1299                    }
1300            }
1301    
1302            protected void initPortalProperties(
1303                            String servletContextName, ClassLoader portletClassLoader,
1304                            Element parentElement)
1305                    throws Exception {
1306    
1307                    String portalPropertiesLocation = parentElement.elementText(
1308                            "portal-properties");
1309    
1310                    if (Validator.isNull(portalPropertiesLocation)) {
1311                            return;
1312                    }
1313    
1314                    Configuration portalPropertiesConfiguration = null;
1315    
1316                    try {
1317                            String name = portalPropertiesLocation;
1318    
1319                            int pos = name.lastIndexOf(".properties");
1320    
1321                            if (pos != -1) {
1322                                    name = name.substring(0, pos);
1323                            }
1324    
1325                            portalPropertiesConfiguration =
1326                                    ConfigurationFactoryUtil.getConfiguration(
1327                                            portletClassLoader, name);
1328                    }
1329                    catch (Exception e) {
1330                            _log.error("Unable to read " + portalPropertiesLocation, e);
1331                    }
1332    
1333                    if (portalPropertiesConfiguration == null) {
1334                            return;
1335                    }
1336    
1337                    Properties portalProperties =
1338                            portalPropertiesConfiguration.getProperties();
1339    
1340                    if (portalProperties.isEmpty()) {
1341                            return;
1342                    }
1343    
1344                    Set<Object> set = portalProperties.keySet();
1345    
1346                    Iterator<Object> iterator = set.iterator();
1347    
1348                    while (iterator.hasNext()) {
1349                            String key = (String)iterator.next();
1350    
1351                            if (!checkPermission(
1352                                            PACLConstants.PORTAL_HOOK_PERMISSION_PORTAL_PROPERTIES_KEY,
1353                                            portletClassLoader, key,
1354                                            "Rejecting portal.properties key " + key)) {
1355    
1356                                    iterator.remove();
1357                            }
1358                    }
1359    
1360                    Properties unfilteredPortalProperties =
1361                            (Properties)portalProperties.clone();
1362    
1363                    portalProperties.remove(PropsKeys.RELEASE_INFO_BUILD_NUMBER);
1364                    portalProperties.remove(PropsKeys.RELEASE_INFO_PREVIOUS_BUILD_NUMBER);
1365                    portalProperties.remove(PropsKeys.UPGRADE_PROCESSES);
1366    
1367                    _portalPropertiesMap.put(servletContextName, portalProperties);
1368    
1369                    // Initialize properties, auto logins, model listeners, and events in
1370                    // that specific order. Events have to be loaded last because they may
1371                    // require model listeners to have been registered.
1372    
1373                    initPortalProperties(
1374                            servletContextName, portletClassLoader, portalProperties,
1375                            unfilteredPortalProperties);
1376                    initAuthFailures(
1377                            servletContextName, portletClassLoader, portalProperties);
1378                    initAutoDeployListeners(
1379                            servletContextName, portletClassLoader, portalProperties);
1380                    initAutoLogins(
1381                            servletContextName, portletClassLoader, portalProperties);
1382                    initAuthenticators(
1383                            servletContextName, portletClassLoader, portalProperties);
1384                    initAuthVerifiers(
1385                            servletContextName, portletClassLoader, portalProperties);
1386                    initFormNavigatorEntries(servletContextName, portalProperties);
1387                    initHotDeployListeners(
1388                            servletContextName, portletClassLoader, portalProperties);
1389                    initModelListeners(
1390                            servletContextName, portletClassLoader, portalProperties);
1391                    initEvents(servletContextName, portletClassLoader, portalProperties);
1392            }
1393    
1394            protected void initPortalProperties(
1395                            String servletContextName, ClassLoader portletClassLoader,
1396                            Properties portalProperties, Properties unfilteredPortalProperties)
1397                    throws Exception {
1398    
1399                    PropsUtil.addProperties(portalProperties);
1400    
1401                    if (_log.isDebugEnabled() && portalProperties.containsKey(LOCALES)) {
1402                            _log.debug(
1403                                    "Portlet locales " + portalProperties.getProperty(LOCALES));
1404                            _log.debug("Merged locales " + PropsUtil.get(LOCALES));
1405                            _log.debug(
1406                                    "Merged locales array length " +
1407                                            PropsUtil.getArray(LOCALES).length);
1408                    }
1409    
1410                    for (String key : _PROPS_VALUES_OBSOLETE) {
1411                            if (_log.isInfoEnabled() && portalProperties.contains(key)) {
1412                                    _log.info("Portal property \"" + key + "\" is obsolete");
1413                            }
1414                    }
1415    
1416                    resetPortalProperties(servletContextName, portalProperties, true);
1417    
1418                    if (portalProperties.containsKey(PropsKeys.AUTH_PUBLIC_PATHS)) {
1419                            initAuthPublicPaths(servletContextName, portalProperties);
1420                    }
1421    
1422                    if (containsKey(portalProperties, AUTH_TOKEN_IGNORE_ACTIONS)) {
1423                            initAuthTokenWhiteListActions(servletContextName, portalProperties);
1424                    }
1425    
1426                    if (portalProperties.containsKey(PropsKeys.AUTH_TOKEN_IMPL)) {
1427                            String authTokenClassName = portalProperties.getProperty(
1428                                    PropsKeys.AUTH_TOKEN_IMPL);
1429    
1430                            AuthToken authToken = (AuthToken)newInstance(
1431                                    portletClassLoader, AuthToken.class, authTokenClassName);
1432    
1433                            registerService(
1434                                    servletContextName, authTokenClassName, AuthToken.class,
1435                                    authToken);
1436                    }
1437    
1438                    if (portalProperties.containsKey(PropsKeys.CAPTCHA_ENGINE_IMPL)) {
1439                            String captchaClassName = portalProperties.getProperty(
1440                                    PropsKeys.CAPTCHA_ENGINE_IMPL);
1441    
1442                            Captcha captcha = (Captcha)newInstance(
1443                                    portletClassLoader, Captcha.class, captchaClassName);
1444    
1445                            CaptchaImpl captchaImpl = null;
1446    
1447                            Captcha currentCaptcha = CaptchaUtil.getCaptcha();
1448    
1449                            if (currentCaptcha instanceof DoPrivilegedBean) {
1450                                    DoPrivilegedBean doPrivilegedBean =
1451                                            (DoPrivilegedBean)currentCaptcha;
1452    
1453                                    captchaImpl = (CaptchaImpl)doPrivilegedBean.getActualBean();
1454                            }
1455                            else {
1456                                    captchaImpl = (CaptchaImpl)currentCaptcha;
1457                            }
1458    
1459                            captchaImpl.setCaptcha(captcha);
1460                    }
1461    
1462                    if (portalProperties.containsKey(
1463                                    PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS)) {
1464    
1465                            String controlPanelEntryClassName = portalProperties.getProperty(
1466                                    PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS);
1467    
1468                            ControlPanelEntry controlPanelEntry =
1469                                    (ControlPanelEntry)newInstance(
1470                                            portletClassLoader, ControlPanelEntry.class,
1471                                            controlPanelEntryClassName);
1472    
1473                            registerService(
1474                                    servletContextName, controlPanelEntryClassName,
1475                                    ControlPanelEntry.class, controlPanelEntry);
1476                    }
1477    
1478                    if (portalProperties.containsKey(PropsKeys.DL_FILE_ENTRY_PROCESSORS)) {
1479                            String[] dlProcessorClassNames = StringUtil.split(
1480                                    portalProperties.getProperty(
1481                                            PropsKeys.DL_FILE_ENTRY_PROCESSORS));
1482    
1483                            DLFileEntryProcessorContainer dlFileEntryProcessorContainer =
1484                                    new DLFileEntryProcessorContainer();
1485    
1486                            _dlFileEntryProcessorContainerMap.put(
1487                                    servletContextName, dlFileEntryProcessorContainer);
1488    
1489                            for (String dlProcessorClassName : dlProcessorClassNames) {
1490                                    DLProcessor dlProcessor =
1491                                            (DLProcessor)InstanceFactory.newInstance(
1492                                                    portletClassLoader, dlProcessorClassName);
1493    
1494                                    dlProcessor = (DLProcessor)newInstance(
1495                                            portletClassLoader,
1496                                            ReflectionUtil.getInterfaces(
1497                                                    dlProcessor, portletClassLoader),
1498                                            dlProcessorClassName);
1499    
1500                                    dlFileEntryProcessorContainer.registerDLProcessor(dlProcessor);
1501                            }
1502                    }
1503    
1504                    if (portalProperties.containsKey(PropsKeys.DL_REPOSITORY_IMPL)) {
1505                            String[] dlRepositoryClassNames = StringUtil.split(
1506                                    portalProperties.getProperty(PropsKeys.DL_REPOSITORY_IMPL));
1507    
1508                            DLRepositoryContainer dlRepositoryContainer =
1509                                    new DLRepositoryContainer();
1510    
1511                            _dlRepositoryContainerMap.put(
1512                                    servletContextName, dlRepositoryContainer);
1513    
1514                            for (String dlRepositoryClassName : dlRepositoryClassNames) {
1515                                    ExternalRepositoryFactory externalRepositoryFactory =
1516                                            new ExternalRepositoryFactoryImpl(
1517                                                    dlRepositoryClassName, portletClassLoader);
1518    
1519                                    dlRepositoryContainer.registerRepositoryFactory(
1520                                            dlRepositoryClassName, externalRepositoryFactory);
1521                            }
1522                    }
1523    
1524                    if (portalProperties.containsKey(PropsKeys.DL_STORE_ANTIVIRUS_IMPL)) {
1525                            String antivirusScannerClassName = portalProperties.getProperty(
1526                                    PropsKeys.DL_STORE_ANTIVIRUS_IMPL);
1527    
1528                            AntivirusScanner antivirusScanner = (AntivirusScanner)newInstance(
1529                                    portletClassLoader, AntivirusScanner.class,
1530                                    antivirusScannerClassName);
1531    
1532                            AntivirusScannerWrapper antivirusScannerWrapper =
1533                                    (AntivirusScannerWrapper)
1534                                            AntivirusScannerUtil.getAntivirusScanner();
1535    
1536                            antivirusScannerWrapper.setAntivirusScanner(antivirusScanner);
1537                    }
1538    
1539                    if (portalProperties.containsKey(PropsKeys.DL_STORE_IMPL)) {
1540                            StoreFactory storeFactory = StoreFactory.getInstance();
1541    
1542                            String storeClassName = portalProperties.getProperty(
1543                                    PropsKeys.DL_STORE_IMPL);
1544    
1545                            storeFactory.setStore(storeClassName);
1546                    }
1547    
1548                    if (portalProperties.containsKey(
1549                                    PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL)) {
1550    
1551                            String attributesTransformerClassName =
1552                                    portalProperties.getProperty(
1553                                            PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL);
1554    
1555                            AttributesTransformer attributesTransformer =
1556                                    (AttributesTransformer)newInstance(
1557                                            portletClassLoader, AttributesTransformer.class,
1558                                            attributesTransformerClassName);
1559    
1560                            registerService(
1561                                    servletContextName, attributesTransformerClassName,
1562                                    AttributesTransformer.class, attributesTransformer);
1563                    }
1564    
1565                    if (portalProperties.containsKey(LOCK_LISTENERS)) {
1566                            String[] lockListenerClassNames = StringUtil.split(
1567                                    portalProperties.getProperty(LOCK_LISTENERS));
1568    
1569                            for (String lockListenerClassName : lockListenerClassNames) {
1570                                    LockListener lockListener = (LockListener)newInstance(
1571                                            portletClassLoader, LockListener.class,
1572                                            lockListenerClassName);
1573    
1574                                    registerService(
1575                                            servletContextName, lockListenerClassName,
1576                                            LockListener.class, lockListener);
1577                            }
1578                    }
1579    
1580                    if (portalProperties.containsKey(PropsKeys.MAIL_HOOK_IMPL)) {
1581                            String mailHookClassName = portalProperties.getProperty(
1582                                    PropsKeys.MAIL_HOOK_IMPL);
1583    
1584                            com.liferay.mail.util.Hook mailHook =
1585                                    (com.liferay.mail.util.Hook)newInstance(
1586                                            portletClassLoader, com.liferay.mail.util.Hook.class,
1587                                            mailHookClassName);
1588    
1589                            registerService(
1590                                    servletContextName, mailHookClassName,
1591                                    com.liferay.mail.util.Hook.class, mailHook);
1592                    }
1593    
1594                    if (portalProperties.containsKey(
1595                                    PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS)) {
1596    
1597                            String organizationMembershipPolicyClassName =
1598                                    portalProperties.getProperty(
1599                                            PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS);
1600    
1601                            OrganizationMembershipPolicy organizationMembershipPolicy =
1602                                    (OrganizationMembershipPolicy)newInstance(
1603                                            portletClassLoader, OrganizationMembershipPolicy.class,
1604                                            organizationMembershipPolicyClassName);
1605    
1606                            registerService(
1607                                    servletContextName, organizationMembershipPolicyClassName,
1608                                    OrganizationMembershipPolicy.class,
1609                                    organizationMembershipPolicy);
1610                    }
1611    
1612                    if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_ROLES)) {
1613                            String roleMembershipPolicyClassName = portalProperties.getProperty(
1614                                    PropsKeys.MEMBERSHIP_POLICY_ROLES);
1615    
1616                            RoleMembershipPolicy roleMembershipPolicy =
1617                                    (RoleMembershipPolicy)newInstance(
1618                                            portletClassLoader, RoleMembershipPolicy.class,
1619                                            roleMembershipPolicyClassName);
1620    
1621                            registerService(
1622                                    servletContextName, roleMembershipPolicyClassName,
1623                                    RoleMembershipPolicy.class, roleMembershipPolicy);
1624                    }
1625    
1626                    if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_SITES)) {
1627                            String siteMembershipPolicyClassName = portalProperties.getProperty(
1628                                    PropsKeys.MEMBERSHIP_POLICY_SITES);
1629    
1630                            SiteMembershipPolicy siteMembershipPolicy =
1631                                    (SiteMembershipPolicy)newInstance(
1632                                            portletClassLoader, SiteMembershipPolicy.class,
1633                                            siteMembershipPolicyClassName);
1634    
1635                            registerService(
1636                                    servletContextName, siteMembershipPolicyClassName,
1637                                    SiteMembershipPolicy.class, siteMembershipPolicy);
1638                    }
1639    
1640                    if (portalProperties.containsKey(
1641                                    PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS)) {
1642    
1643                            String userGroupMembershipPolicyClassName =
1644                                    portalProperties.getProperty(
1645                                            PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS);
1646    
1647                            UserGroupMembershipPolicy userGroupMembershipPolicy =
1648                                    (UserGroupMembershipPolicy)newInstance(
1649                                            portletClassLoader, UserGroupMembershipPolicy.class,
1650                                            userGroupMembershipPolicyClassName);
1651    
1652                            registerService(
1653                                    servletContextName, userGroupMembershipPolicyClassName,
1654                                    UserGroupMembershipPolicy.class, userGroupMembershipPolicy);
1655                    }
1656    
1657                    if (portalProperties.containsKey(PropsKeys.PASSWORDS_TOOLKIT)) {
1658                            String toolkitClassName = portalProperties.getProperty(
1659                                    PropsKeys.PASSWORDS_TOOLKIT);
1660    
1661                            Toolkit toolkit = (Toolkit)newInstance(
1662                                    portletClassLoader, Toolkit.class, toolkitClassName);
1663    
1664                            registerService(
1665                                    servletContextName, toolkitClassName, Toolkit.class, toolkit);
1666                    }
1667    
1668                    if (portalProperties.containsKey(PropsKeys.PHONE_NUMBER_FORMAT_IMPL)) {
1669                            String phoneNumberFormatClassName = portalProperties.getProperty(
1670                                    PropsKeys.PHONE_NUMBER_FORMAT_IMPL);
1671    
1672                            PhoneNumberFormat phoneNumberFormat =
1673                                    (PhoneNumberFormat)newInstance(
1674                                            portletClassLoader, PhoneNumberFormat.class,
1675                                            phoneNumberFormatClassName);
1676    
1677                            registerService(
1678                                    servletContextName, phoneNumberFormatClassName,
1679                                    PhoneNumberFormat.class, phoneNumberFormat);
1680                    }
1681    
1682                    if (portalProperties.containsKey(PropsKeys.SANITIZER_IMPL)) {
1683                            String[] sanitizerClassNames = StringUtil.split(
1684                                    portalProperties.getProperty(PropsKeys.SANITIZER_IMPL));
1685    
1686                            for (String sanitizerClassName : sanitizerClassNames) {
1687                                    Sanitizer sanitizer = (Sanitizer)newInstance(
1688                                            portletClassLoader, Sanitizer.class, sanitizerClassName);
1689    
1690                                    registerService(
1691                                            servletContextName, sanitizerClassName, Sanitizer.class,
1692                                            sanitizer);
1693                            }
1694                    }
1695    
1696                    if (portalProperties.containsKey(
1697                                    PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR)) {
1698    
1699                            String emailAddressGeneratorClassName =
1700                                    portalProperties.getProperty(
1701                                            PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR);
1702    
1703                            EmailAddressGenerator emailAddressGenerator =
1704                                    (EmailAddressGenerator)newInstance(
1705                                            portletClassLoader, EmailAddressGenerator.class,
1706                                            emailAddressGeneratorClassName);
1707    
1708                            registerService(
1709                                    servletContextName, emailAddressGeneratorClassName,
1710                                    EmailAddressGenerator.class, emailAddressGenerator);
1711                    }
1712    
1713                    if (portalProperties.containsKey(
1714                                    PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR)) {
1715    
1716                            String emailAddressValidatorClassName =
1717                                    portalProperties.getProperty(
1718                                            PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR);
1719    
1720                            EmailAddressValidator emailAddressValidator =
1721                                    (EmailAddressValidator)newInstance(
1722                                            portletClassLoader, EmailAddressValidator.class,
1723                                            emailAddressValidatorClassName);
1724    
1725                            registerService(
1726                                    servletContextName, emailAddressValidatorClassName,
1727                                    EmailAddressValidator.class, emailAddressValidator);
1728                    }
1729    
1730                    if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_GENERATOR)) {
1731                            String fullNameGeneratorClassName = portalProperties.getProperty(
1732                                    PropsKeys.USERS_FULL_NAME_GENERATOR);
1733    
1734                            FullNameGenerator fullNameGenerator =
1735                                    (FullNameGenerator)newInstance(
1736                                            portletClassLoader, FullNameGenerator.class,
1737                                            fullNameGeneratorClassName);
1738    
1739                            registerService(
1740                                    servletContextName, fullNameGeneratorClassName,
1741                                    FullNameGenerator.class, fullNameGenerator);
1742                    }
1743    
1744                    if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_VALIDATOR)) {
1745                            String fullNameValidatorClassName = portalProperties.getProperty(
1746                                    PropsKeys.USERS_FULL_NAME_VALIDATOR);
1747    
1748                            FullNameValidator fullNameValidator =
1749                                    (FullNameValidator)newInstance(
1750                                            portletClassLoader, FullNameValidator.class,
1751                                            fullNameValidatorClassName);
1752    
1753                            registerService(
1754                                    servletContextName, fullNameValidatorClassName,
1755                                    FullNameValidator.class, fullNameValidator);
1756                    }
1757    
1758                    if (portalProperties.containsKey(
1759                                    PropsKeys.USERS_SCREEN_NAME_GENERATOR)) {
1760    
1761                            String screenNameGeneratorClassName = portalProperties.getProperty(
1762                                    PropsKeys.USERS_SCREEN_NAME_GENERATOR);
1763    
1764                            ScreenNameGenerator screenNameGenerator =
1765                                    (ScreenNameGenerator)newInstance(
1766                                            portletClassLoader, ScreenNameGenerator.class,
1767                                            screenNameGeneratorClassName);
1768    
1769                            registerService(
1770                                    servletContextName, screenNameGeneratorClassName,
1771                                    ScreenNameGenerator.class, screenNameGenerator);
1772                    }
1773    
1774                    if (portalProperties.containsKey(
1775                                    PropsKeys.USERS_SCREEN_NAME_VALIDATOR)) {
1776    
1777                            String screenNameValidatorClassName = portalProperties.getProperty(
1778                                    PropsKeys.USERS_SCREEN_NAME_VALIDATOR);
1779    
1780                            ScreenNameValidator screenNameValidator =
1781                                    (ScreenNameValidator)newInstance(
1782                                            portletClassLoader, ScreenNameValidator.class,
1783                                            screenNameValidatorClassName);
1784    
1785                            registerService(
1786                                    servletContextName, screenNameValidatorClassName,
1787                                    ScreenNameValidator.class, screenNameValidator);
1788                    }
1789    
1790                    Set<String> liferayFilterClassNames =
1791                            LiferayFilterTracker.getClassNames();
1792    
1793                    for (String liferayFilterClassName : liferayFilterClassNames) {
1794                            if (!portalProperties.containsKey(liferayFilterClassName)) {
1795                                    continue;
1796                            }
1797    
1798                            boolean filterEnabled = GetterUtil.getBoolean(
1799                                    portalProperties.getProperty(liferayFilterClassName));
1800    
1801                            Set<LiferayFilter> liferayFilters =
1802                                    LiferayFilterTracker.getLiferayFilters(liferayFilterClassName);
1803    
1804                            for (LiferayFilter liferayFilter : liferayFilters) {
1805                                    liferayFilter.setFilterEnabled(filterEnabled);
1806                            }
1807                    }
1808    
1809                    if (unfilteredPortalProperties.containsKey(
1810                                    PropsKeys.RELEASE_INFO_BUILD_NUMBER) ||
1811                            unfilteredPortalProperties.containsKey(
1812                                    PropsKeys.UPGRADE_PROCESSES)) {
1813    
1814                            String[] upgradeProcessClassNames = StringUtil.split(
1815                                    unfilteredPortalProperties.getProperty(
1816                                            PropsKeys.UPGRADE_PROCESSES));
1817    
1818                            List<UpgradeProcess> upgradeProcesses =
1819                                    UpgradeProcessUtil.initUpgradeProcesses(
1820                                            portletClassLoader, upgradeProcessClassNames);
1821    
1822                            ReleaseLocalServiceUtil.updateRelease(
1823                                    servletContextName, upgradeProcesses,
1824                                    unfilteredPortalProperties);
1825                    }
1826            }
1827    
1828            protected void initServices(
1829                            String servletContextName, ClassLoader portletClassLoader,
1830                            Element parentElement)
1831                    throws Exception {
1832    
1833                    List<Element> serviceElements = parentElement.elements("service");
1834    
1835                    for (Element serviceElement : serviceElements) {
1836                            String serviceType = serviceElement.elementText("service-type");
1837                            String serviceImpl = serviceElement.elementText("service-impl");
1838    
1839                            if (!checkPermission(
1840                                            PACLConstants.PORTAL_HOOK_PERMISSION_SERVICE,
1841                                            portletClassLoader, serviceType,
1842                                            "Rejecting service " + serviceImpl)) {
1843    
1844                                    continue;
1845                            }
1846    
1847                            Class<?> serviceTypeClass = portletClassLoader.loadClass(
1848                                    serviceType);
1849    
1850                            Class<?> serviceImplClass = portletClassLoader.loadClass(
1851                                    serviceImpl);
1852    
1853                            Constructor<?> serviceImplConstructor =
1854                                    serviceImplClass.getConstructor(
1855                                            new Class<?>[] {serviceTypeClass});
1856    
1857                            Object serviceProxy = null;
1858    
1859                            try {
1860                                    serviceProxy = PortalBeanLocatorUtil.locate(serviceType);
1861                            }
1862                            catch (BeanLocatorException ble) {
1863                                    Registry registry = RegistryUtil.getRegistry();
1864    
1865                                    serviceProxy = registry.getService(serviceTypeClass);
1866                            }
1867    
1868                            if (ProxyUtil.isProxyClass(serviceProxy.getClass())) {
1869                                    initServices(
1870                                            servletContextName, portletClassLoader, serviceType,
1871                                            serviceTypeClass, serviceImplConstructor, serviceProxy);
1872                            }
1873                            else {
1874                                    _log.error(
1875                                            "Service hooks require Spring to be configured to use " +
1876                                                    "JdkDynamicProxy and will not work with CGLIB");
1877                            }
1878                    }
1879            }
1880    
1881            protected void initServices(
1882                            String servletContextName, ClassLoader portletClassLoader,
1883                            String serviceType, Class<?> serviceTypeClass,
1884                            Constructor<?> serviceImplConstructor, Object serviceProxy)
1885                    throws Exception {
1886    
1887                    AdvisedSupport advisedSupport = ServiceBeanAopProxy.getAdvisedSupport(
1888                            serviceProxy);
1889    
1890                    TargetSource targetSource = advisedSupport.getTargetSource();
1891    
1892                    Object previousService = targetSource.getTarget();
1893    
1894                    ServiceWrapper<?> serviceWrapper =
1895                            (ServiceWrapper<?>)serviceImplConstructor.newInstance(
1896                                    previousService);
1897    
1898                    registerService(
1899                            servletContextName, serviceImplConstructor, ServiceWrapper.class,
1900                            serviceWrapper);
1901            }
1902    
1903            protected Filter initServletFilter(
1904                            String filterClassName, ClassLoader portletClassLoader)
1905                    throws Exception {
1906    
1907                    Filter filter = (Filter)InstanceFactory.newInstance(
1908                            portletClassLoader, filterClassName);
1909    
1910                    List<Class<?>> interfaces = new ArrayList<>();
1911    
1912                    if (filter instanceof TryFilter) {
1913                            interfaces.add(TryFilter.class);
1914                    }
1915    
1916                    if (filter instanceof TryFinallyFilter) {
1917                            interfaces.add(TryFinallyFilter.class);
1918                    }
1919    
1920                    if (filter instanceof WrapHttpServletRequestFilter) {
1921                            interfaces.add(WrapHttpServletRequestFilter.class);
1922                    }
1923    
1924                    if (filter instanceof WrapHttpServletResponseFilter) {
1925                            interfaces.add(WrapHttpServletResponseFilter.class);
1926                    }
1927    
1928                    if (filter instanceof LiferayFilter) {
1929                            interfaces.add(LiferayFilter.class);
1930                    }
1931                    else {
1932                            interfaces.add(Filter.class);
1933                    }
1934    
1935                    filter = (Filter)ProxyUtil.newProxyInstance(
1936                            portletClassLoader,
1937                            interfaces.toArray(new Class[interfaces.size()]),
1938                            new ClassLoaderBeanHandler(filter, portletClassLoader));
1939    
1940                    return filter;
1941            }
1942    
1943            protected void initServletFilters(
1944                            ServletContext servletContext, String servletContextName,
1945                            ClassLoader portletClassLoader, Element parentElement)
1946                    throws Exception {
1947    
1948                    List<Element> servletFilterElements = parentElement.elements(
1949                            "servlet-filter");
1950    
1951                    if (!servletFilterElements.isEmpty() &&
1952                            !checkPermission(
1953                                    PACLConstants.PORTAL_HOOK_PERMISSION_SERVLET_FILTERS,
1954                                    portletClassLoader, null, "Rejecting servlet filters")) {
1955    
1956                            return;
1957                    }
1958    
1959                    Map<String, Tuple> filterTuples = new HashMap<>();
1960    
1961                    List<Element> servletFilterMappingElements = parentElement.elements(
1962                            "servlet-filter-mapping");
1963    
1964                    for (Element servletFilterMappingElement :
1965                                    servletFilterMappingElements) {
1966    
1967                            String servletFilterName = servletFilterMappingElement.elementText(
1968                                    "servlet-filter-name");
1969                            String afterFilter = servletFilterMappingElement.elementText(
1970                                    "after-filter");
1971                            String beforeFilter = servletFilterMappingElement.elementText(
1972                                    "before-filter");
1973    
1974                            List<Element> urlPatternElements =
1975                                    servletFilterMappingElement.elements("url-pattern");
1976    
1977                            List<String> urlPatterns = new ArrayList<>();
1978    
1979                            for (Element urlPatternElement : urlPatternElements) {
1980                                    String urlPattern = urlPatternElement.getTextTrim();
1981    
1982                                    urlPatterns.add(urlPattern);
1983                            }
1984    
1985                            List<Element> dispatcherElements =
1986                                    servletFilterMappingElement.elements("dispatcher");
1987    
1988                            List<String> dispatchers = new ArrayList<>();
1989    
1990                            for (Element dispatcherElement : dispatcherElements) {
1991                                    String dispatcher = dispatcherElement.getTextTrim();
1992    
1993                                    dispatcher = StringUtil.toUpperCase(dispatcher);
1994    
1995                                    dispatchers.add(dispatcher);
1996                            }
1997    
1998                            filterTuples.put(
1999                                    servletFilterName,
2000                                    new Tuple(afterFilter, beforeFilter, dispatchers, urlPatterns));
2001                    }
2002    
2003                    for (Element servletFilterElement : servletFilterElements) {
2004                            String servletFilterName = servletFilterElement.elementText(
2005                                    "servlet-filter-name");
2006                            String servletFilterImpl = servletFilterElement.elementText(
2007                                    "servlet-filter-impl");
2008    
2009                            List<Element> initParamElements = servletFilterElement.elements(
2010                                    "init-param");
2011    
2012                            Map<String, Object> properties = new HashMap<>();
2013    
2014                            for (Element initParamElement : initParamElements) {
2015                                    String paramName = initParamElement.elementText("param-name");
2016                                    String paramValue = initParamElement.elementText("param-value");
2017    
2018                                    properties.put("init.param." + paramName, paramValue);
2019                            }
2020    
2021                            Tuple filterTuple = filterTuples.get(servletFilterName);
2022    
2023                            properties.put("after-filter", filterTuple.getObject(0));
2024                            properties.put("before-filter", filterTuple.getObject(1));
2025                            properties.put("dispatcher", filterTuple.getObject(2));
2026                            properties.put(
2027                                    "servlet-context-name",
2028                                    PortalContextLoaderListener.getPortalServletContextName());
2029                            properties.put("servlet-filter-name", servletFilterName);
2030                            properties.put("url-pattern", filterTuple.getObject(3));
2031    
2032                            Filter filter = initServletFilter(
2033                                    servletFilterImpl, portletClassLoader);
2034    
2035                            registerService(
2036                                    servletContextName, servletFilterName, Filter.class, filter,
2037                                    properties);
2038                    }
2039            }
2040    
2041            protected void initStrutsAction(
2042                            String servletContextName, ClassLoader portletClassLoader,
2043                            String strutsActionPath, String strutsActionClassName)
2044                    throws Exception {
2045    
2046                    Object strutsActionObject = InstanceFactory.newInstance(
2047                            portletClassLoader, strutsActionClassName);
2048    
2049                    if (strutsActionObject instanceof StrutsAction) {
2050                            StrutsAction strutsAction =
2051                                    (StrutsAction)ProxyUtil.newProxyInstance(
2052                                            portletClassLoader, new Class[] {StrutsAction.class},
2053                                            new ClassLoaderBeanHandler(
2054                                                    strutsActionObject, portletClassLoader));
2055    
2056                            registerService(
2057                                    servletContextName, strutsActionClassName, StrutsAction.class,
2058                                    strutsAction, "path", strutsActionPath);
2059                    }
2060                    else {
2061                            StrutsPortletAction strutsPortletAction =
2062                                    (StrutsPortletAction)ProxyUtil.newProxyInstance(
2063                                            portletClassLoader, new Class[] {StrutsPortletAction.class},
2064                                            new ClassLoaderBeanHandler(
2065                                                    strutsActionObject, portletClassLoader));
2066    
2067                            registerService(
2068                                    servletContextName, strutsActionClassName,
2069                                    StrutsPortletAction.class, strutsPortletAction, "path",
2070                                    strutsActionPath);
2071                    }
2072            }
2073    
2074            protected void initStrutsActions(
2075                            String servletContextName, ClassLoader portletClassLoader,
2076                            Element parentElement)
2077                    throws Exception {
2078    
2079                    List<Element> strutsActionElements = parentElement.elements(
2080                            "struts-action");
2081    
2082                    for (Element strutsActionElement : strutsActionElements) {
2083                            String strutsActionPath = strutsActionElement.elementText(
2084                                    "struts-action-path");
2085    
2086                            if (!checkPermission(
2087                                            PACLConstants.PORTAL_HOOK_PERMISSION_STRUTS_ACTION_PATH,
2088                                            portletClassLoader, strutsActionPath,
2089                                            "Rejecting struts action path " + strutsActionPath)) {
2090    
2091                                    continue;
2092                            }
2093    
2094                            String strutsActionImpl = strutsActionElement.elementText(
2095                                    "struts-action-impl");
2096    
2097                            initStrutsAction(
2098                                    servletContextName, portletClassLoader, strutsActionPath,
2099                                    strutsActionImpl);
2100                    }
2101            }
2102    
2103            protected <S, T> Map<S, T> newMap() {
2104                    return new ConcurrentHashMap<>();
2105            }
2106    
2107            protected void resetPortalProperties(
2108                            String servletContextName, Properties portalProperties,
2109                            boolean initPhase)
2110                    throws Exception {
2111    
2112                    for (String key : _PROPS_VALUES_BOOLEAN) {
2113                            String fieldName = StringUtil.replace(
2114                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2115                                    CharPool.UNDERLINE);
2116    
2117                            if (!containsKey(portalProperties, key)) {
2118                                    continue;
2119                            }
2120    
2121                            try {
2122                                    Field field = PropsValues.class.getField(fieldName);
2123    
2124                                    Boolean value = Boolean.valueOf(
2125                                            GetterUtil.getBoolean(PropsUtil.get(key)));
2126    
2127                                    field.setBoolean(null, value);
2128                            }
2129                            catch (Exception e) {
2130                                    _log.error(
2131                                            "Error setting field " + fieldName + ": " + e.getMessage());
2132                            }
2133                    }
2134    
2135                    for (String key : _PROPS_VALUES_INTEGER) {
2136                            String fieldName = StringUtil.replace(
2137                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2138                                    CharPool.UNDERLINE);
2139    
2140                            if (!containsKey(portalProperties, key)) {
2141                                    continue;
2142                            }
2143    
2144                            try {
2145                                    Field field = PropsValues.class.getField(fieldName);
2146    
2147                                    Integer value = Integer.valueOf(
2148                                            GetterUtil.getInteger(PropsUtil.get(key)));
2149    
2150                                    field.setInt(null, value);
2151                            }
2152                            catch (Exception e) {
2153                                    _log.error(
2154                                            "Error setting field " + fieldName + ": " + e.getMessage());
2155                            }
2156                    }
2157    
2158                    for (String key : _PROPS_VALUES_LONG) {
2159                            String fieldName = StringUtil.replace(
2160                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2161                                    CharPool.UNDERLINE);
2162    
2163                            if (!containsKey(portalProperties, key)) {
2164                                    continue;
2165                            }
2166    
2167                            try {
2168                                    Field field = PropsValues.class.getField(fieldName);
2169    
2170                                    Long value = Long.valueOf(
2171                                            GetterUtil.getLong(PropsUtil.get(key)));
2172    
2173                                    field.setLong(null, value);
2174                            }
2175                            catch (Exception e) {
2176                                    _log.error(
2177                                            "Error setting field " + fieldName + ": " + e.getMessage());
2178                            }
2179                    }
2180    
2181                    for (String key : _PROPS_VALUES_STRING) {
2182                            String fieldName = StringUtil.replace(
2183                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2184                                    CharPool.UNDERLINE);
2185    
2186                            if (!containsKey(portalProperties, key)) {
2187                                    continue;
2188                            }
2189    
2190                            try {
2191                                    Field field = PropsValues.class.getField(fieldName);
2192    
2193                                    String value = GetterUtil.getString(PropsUtil.get(key));
2194    
2195                                    field.set(null, value);
2196                            }
2197                            catch (Exception e) {
2198                                    _log.error(
2199                                            "Error setting field " + fieldName + ": " + e.getMessage());
2200                            }
2201                    }
2202    
2203                    resetPortalPropertiesStringArray(
2204                            servletContextName, portalProperties, initPhase,
2205                            _PROPS_VALUES_MERGE_STRING_ARRAY, _mergeStringArraysContainerMap);
2206    
2207                    resetPortalPropertiesStringArray(
2208                            servletContextName, portalProperties, initPhase,
2209                            _PROPS_VALUES_OVERRIDE_STRING_ARRAY,
2210                            _overrideStringArraysContainerMap);
2211    
2212                    if (containsKey(portalProperties, LOCALES) ||
2213                            containsKey(portalProperties, LOCALES_BETA)) {
2214    
2215                            PropsValues.LOCALES = PropsUtil.getArray(LOCALES);
2216    
2217                            LanguageUtil.init();
2218                    }
2219    
2220                    if (containsKey(portalProperties, LOCALES_ENABLED)) {
2221                            PropsValues.LOCALES_ENABLED = PropsUtil.getArray(LOCALES_ENABLED);
2222    
2223                            LanguageUtil.init();
2224                    }
2225    
2226                    if (containsKey(portalProperties, AUTH_TOKEN_IGNORE_ORIGINS)) {
2227                            AuthTokenWhitelistUtil.resetOriginCSRFWhitelist();
2228                    }
2229    
2230                    if (containsKey(portalProperties, AUTH_TOKEN_IGNORE_PORTLETS)) {
2231                            AuthTokenWhitelistUtil.resetPortletCSRFWhitelist();
2232                    }
2233    
2234                    if (containsKey(
2235                                    portalProperties,
2236                                    PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST)) {
2237    
2238                            AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
2239                    }
2240    
2241                    if (containsKey(
2242                                    portalProperties,
2243                                    PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST_ACTIONS)) {
2244    
2245                            AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
2246                    }
2247    
2248                    if (containsKey(
2249                                    portalProperties, PORTLET_INTERRUPTED_REQUEST_WHITELIST)) {
2250    
2251                            InterruptedPortletRequestWhitelistUtil.
2252                                    resetPortletInvocationWhitelist();
2253                    }
2254    
2255                    if (containsKey(
2256                                    portalProperties,
2257                                    PORTLET_INTERRUPTED_REQUEST_WHITELIST_ACTIONS)) {
2258    
2259                            InterruptedPortletRequestWhitelistUtil.
2260                                    resetPortletInvocationWhitelistActions();
2261                    }
2262    
2263                    CacheUtil.clearCache();
2264    
2265                    JavaScriptBundleUtil.clearCache();
2266            }
2267    
2268            protected void resetPortalPropertiesStringArray(
2269                    String servletContextName, Properties portalProperties,
2270                    boolean initPhase, String[] propsValuesStringArray,
2271                    Map<String, StringArraysContainer> stringArraysContainerMap) {
2272    
2273                    for (String key : propsValuesStringArray) {
2274                            String fieldName = StringUtil.replace(
2275                                    StringUtil.toUpperCase(key), CharPool.PERIOD,
2276                                    CharPool.UNDERLINE);
2277    
2278                            if (!containsKey(portalProperties, key)) {
2279                                    continue;
2280                            }
2281    
2282                            try {
2283                                    resetPortalPropertiesStringArray(
2284                                            servletContextName, portalProperties, initPhase,
2285                                            propsValuesStringArray, stringArraysContainerMap, key,
2286                                            fieldName);
2287                            }
2288                            catch (Exception e) {
2289                                    _log.error(
2290                                            "Error setting field " + fieldName + ": " + e.getMessage());
2291                            }
2292                    }
2293            }
2294    
2295            protected void resetPortalPropertiesStringArray(
2296                            String servletContextName, Properties portalProperties,
2297                            boolean initPhase, String[] propsValuesStringArray,
2298                            Map<String, StringArraysContainer> stringArraysContainerMap,
2299                            String key, String fieldName)
2300                    throws Exception {
2301    
2302                    Field field = PropsValues.class.getField(fieldName);
2303    
2304                    StringArraysContainer stringArraysContainer =
2305                            stringArraysContainerMap.get(key);
2306    
2307                    String[] value = null;
2308    
2309                    if (initPhase) {
2310                            if (stringArraysContainer
2311                                            instanceof OverrideStringArraysContainer) {
2312    
2313                                    OverrideStringArraysContainer overrideStringArraysContainer =
2314                                            (OverrideStringArraysContainer)stringArraysContainer;
2315    
2316                                    if (overrideStringArraysContainer.isOverridden()) {
2317                                            _log.error("Error setting overridden field " + fieldName);
2318    
2319                                            return;
2320                                    }
2321    
2322                                    value = StringUtil.split(portalProperties.getProperty(key));
2323                            }
2324                            else {
2325                                    value = PropsUtil.getArray(key);
2326                            }
2327                    }
2328    
2329                    stringArraysContainer.setPluginStringArray(servletContextName, value);
2330    
2331                    value = stringArraysContainer.getStringArray();
2332    
2333                    field.set(null, value);
2334            }
2335    
2336            private static final String[] _PROPS_KEYS_EVENTS = {
2337                    LOGIN_EVENTS_POST, LOGIN_EVENTS_PRE, LOGOUT_EVENTS_POST,
2338                    LOGOUT_EVENTS_PRE, SERVLET_SERVICE_EVENTS_POST,
2339                    SERVLET_SERVICE_EVENTS_PRE
2340            };
2341    
2342            private static final String[] _PROPS_KEYS_SESSION_EVENTS = {
2343                    SERVLET_SESSION_CREATE_EVENTS, SERVLET_SESSION_DESTROY_EVENTS
2344            };
2345    
2346            private static final String[] _PROPS_VALUES_BOOLEAN = {
2347                    "auth.forward.by.last.path", "captcha.check.portal.create_account",
2348                    "dl.file.entry.drafts.enabled",
2349                    "dl.file.entry.open.in.ms.office.manual.check.in.required",
2350                    "field.enable.com.liferay.portal.model.Contact.birthday",
2351                    "field.enable.com.liferay.portal.model.Contact.male",
2352                    "field.enable.com.liferay.portal.model.Organization.status",
2353                    "javascript.fast.load", "layout.template.cache.enabled",
2354                    "layout.user.private.layouts.auto.create",
2355                    "layout.user.private.layouts.enabled",
2356                    "layout.user.private.layouts.power.user.required",
2357                    "layout.user.public.layouts.auto.create",
2358                    "layout.user.public.layouts.enabled",
2359                    "layout.user.public.layouts.power.user.required",
2360                    "login.create.account.allow.custom.password", "login.dialog.disabled",
2361                    "my.sites.show.private.sites.with.no.layouts",
2362                    "my.sites.show.public.sites.with.no.layouts",
2363                    "my.sites.show.user.private.sites.with.no.layouts",
2364                    "my.sites.show.user.public.sites.with.no.layouts",
2365                    "portlet.add.default.resource.check.enabled", "rss.feeds.enabled",
2366                    "session.store.password", "social.activity.sets.bundling.enabled",
2367                    "social.activity.sets.enabled", "terms.of.use.required",
2368                    "theme.css.fast.load", "theme.images.fast.load",
2369                    "theme.jsp.override.enabled", "theme.loader.new.theme.id.on.import",
2370                    "theme.portlet.decorate.default", "theme.portlet.sharing.default",
2371                    "user.notification.event.confirmation.enabled",
2372                    "users.email.address.required", "users.image.check.token",
2373                    "users.screen.name.always.autogenerate"
2374            };
2375    
2376            private static final String[] _PROPS_VALUES_INTEGER = {
2377                    "session.max.allowed", "users.image.max.height", "users.image.max.width"
2378            };
2379    
2380            private static final String[] _PROPS_VALUES_LONG = {};
2381    
2382            private static final String[] _PROPS_VALUES_MERGE_STRING_ARRAY = {
2383                    "asset.publisher.query.form.configuration", "auth.token.ignore.actions",
2384                    "auth.token.ignore.origins", "auth.token.ignore.portlets",
2385                    "admin.default.group.names", "admin.default.role.names",
2386                    "admin.default.user.group.names", "asset.publisher.display.styles",
2387                    "company.settings.form.authentication",
2388                    "company.settings.form.configuration",
2389                    "company.settings.form.identification",
2390                    "company.settings.form.miscellaneous", "company.settings.form.social",
2391                    "dockbar.add.portlets", "journal.article.form.add",
2392                    "journal.article.form.translate", "journal.article.form.update",
2393                    "layout.form.add", "layout.form.update", "layout.set.form.update",
2394                    "layout.static.portlets.all", "login.form.navigation.post",
2395                    "login.form.navigation.pre", "organizations.form.add.identification",
2396                    "organizations.form.add.main", "organizations.form.add.miscellaneous",
2397                    "portlet.add.default.resource.check.whitelist",
2398                    "portlet.add.default.resource.check.whitelist.actions",
2399                    "portlet.interrupted.request.whitelist",
2400                    "portlet.interrupted.request.whitelist.actions",
2401                    "session.phishing.protected.attributes", "sites.form.add.advanced",
2402                    "sites.form.add.main", "sites.form.add.miscellaneous",
2403                    "sites.form.add.seo", "sites.form.update.advanced",
2404                    "sites.form.update.main", "sites.form.update.miscellaneous",
2405                    "sites.form.update.seo", "users.form.add.identification",
2406                    "users.form.add.main", "users.form.add.miscellaneous",
2407                    "users.form.my.account.identification", "users.form.my.account.main",
2408                    "users.form.my.account.miscellaneous",
2409                    "users.form.update.identification", "users.form.update.main",
2410                    "users.form.update.miscellaneous"
2411            };
2412    
2413            private static final String[] _PROPS_VALUES_OBSOLETE = {
2414                    "layout.user.private.layouts.modifiable",
2415                    "layout.user.public.layouts.modifiable"
2416            };
2417    
2418            private static final String[] _PROPS_VALUES_OVERRIDE_STRING_ARRAY = {
2419                    "locales.beta"
2420            };
2421    
2422            private static final String[] _PROPS_VALUES_STRING = {
2423                    "company.default.locale", "company.default.time.zone",
2424                    "default.landing.page.path", "default.regular.color.scheme.id",
2425                    "default.regular.theme.id", "default.wap.color.scheme.id",
2426                    "default.wap.theme.id", "passwords.passwordpolicytoolkit.generator",
2427                    "passwords.passwordpolicytoolkit.static",
2428                    "phone.number.format.international.regexp",
2429                    "phone.number.format.usa.regexp", "social.activity.sets.selector",
2430                    "theme.shortcut.icon"
2431            };
2432    
2433            private static final Log _log = LogFactoryUtil.getLog(
2434                    HookHotDeployListener.class);
2435    
2436            private final Map<String, DLFileEntryProcessorContainer>
2437                    _dlFileEntryProcessorContainerMap = new HashMap<>();
2438            private final Map<String, DLRepositoryContainer> _dlRepositoryContainerMap =
2439                    new HashMap<>();
2440            private final Map<String, HotDeployListenersContainer>
2441                    _hotDeployListenersContainerMap = new HashMap<>();
2442            private final Map<String, StringArraysContainer>
2443                    _mergeStringArraysContainerMap = new HashMap<>();
2444            private final Map<String, StringArraysContainer>
2445                    _overrideStringArraysContainerMap = new HashMap<>();
2446            private final Map<String, Properties> _portalPropertiesMap =
2447                    new HashMap<>();
2448            private final Set<String> _propsKeysEvents = SetUtil.fromArray(
2449                    _PROPS_KEYS_EVENTS);
2450            private final Set<String> _propsKeysSessionEvents = SetUtil.fromArray(
2451                    _PROPS_KEYS_SESSION_EVENTS);
2452            private final Map<String, Map<Object, ServiceRegistration<?>>>
2453                    _serviceRegistrations = newMap();
2454            private final Set<String> _servletContextNames = new HashSet<>();
2455    
2456            private class DLFileEntryProcessorContainer {
2457    
2458                    public void registerDLProcessor(DLProcessor dlProcessor) {
2459                            DLProcessorRegistryUtil.register(dlProcessor);
2460    
2461                            _dlProcessors.add(dlProcessor);
2462                    }
2463    
2464                    public void unregisterDLProcessors() {
2465                            for (DLProcessor dlProcessor : _dlProcessors) {
2466                                    DLProcessorRegistryUtil.unregister(dlProcessor);
2467                            }
2468    
2469                            _dlProcessors.clear();
2470                    }
2471    
2472                    private final List<DLProcessor> _dlProcessors = new ArrayList<>();
2473    
2474            }
2475    
2476            private class DLRepositoryContainer {
2477    
2478                    public void registerRepositoryFactory(
2479                            String className,
2480                            ExternalRepositoryFactory externalRepositoryFactory) {
2481    
2482                            RepositoryClassDefinitionCatalogUtil.
2483                                    registerLegacyExternalRepositoryFactory(
2484                                            className, externalRepositoryFactory);
2485    
2486                            _classNames.add(className);
2487                    }
2488    
2489                    public void unregisterRepositoryFactories() {
2490                            for (String className : _classNames) {
2491                                    RepositoryClassDefinitionCatalogUtil.
2492                                            unregisterLegacyExternalRepositoryFactory(className);
2493                            }
2494    
2495                            _classNames.clear();
2496                    }
2497    
2498                    private final List<String> _classNames = new ArrayList<>();
2499    
2500            }
2501    
2502            private class HotDeployListenersContainer {
2503    
2504                    public void registerHotDeployListener(
2505                            HotDeployListener hotDeployListener) {
2506    
2507                            HotDeployUtil.registerListener(hotDeployListener);
2508    
2509                            _hotDeployListeners.add(hotDeployListener);
2510                    }
2511    
2512                    public void unregisterHotDeployListeners() {
2513                            for (HotDeployListener hotDeployListener : _hotDeployListeners) {
2514                                    HotDeployUtil.unregisterListener(hotDeployListener);
2515                            }
2516                    }
2517    
2518                    private final List<HotDeployListener> _hotDeployListeners =
2519                            new ArrayList<>();
2520    
2521            }
2522    
2523            private class MergeStringArraysContainer 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 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    }