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