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