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