001
014
015 package com.liferay.portal.deploy.hot;
016
017 import com.liferay.portal.captcha.CaptchaImpl;
018 import com.liferay.portal.events.EventsProcessorUtil;
019 import com.liferay.portal.kernel.bean.ClassLoaderBeanHandler;
020 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
021 import com.liferay.portal.kernel.captcha.Captcha;
022 import com.liferay.portal.kernel.captcha.CaptchaUtil;
023 import com.liferay.portal.kernel.configuration.Configuration;
024 import com.liferay.portal.kernel.configuration.ConfigurationFactoryUtil;
025 import com.liferay.portal.kernel.deploy.auto.AutoDeployDir;
026 import com.liferay.portal.kernel.deploy.auto.AutoDeployListener;
027 import com.liferay.portal.kernel.deploy.auto.AutoDeployUtil;
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.SessionAction;
038 import com.liferay.portal.kernel.events.SimpleAction;
039 import com.liferay.portal.kernel.exception.PortalException;
040 import com.liferay.portal.kernel.format.PhoneNumberFormat;
041 import com.liferay.portal.kernel.format.PhoneNumberFormatUtil;
042 import com.liferay.portal.kernel.format.PhoneNumberFormatWrapper;
043 import com.liferay.portal.kernel.language.LanguageUtil;
044 import com.liferay.portal.kernel.lock.LockListener;
045 import com.liferay.portal.kernel.lock.LockListenerRegistryUtil;
046 import com.liferay.portal.kernel.log.Log;
047 import com.liferay.portal.kernel.log.LogFactoryUtil;
048 import com.liferay.portal.kernel.plugin.PluginPackage;
049 import com.liferay.portal.kernel.sanitizer.Sanitizer;
050 import com.liferay.portal.kernel.sanitizer.SanitizerUtil;
051 import com.liferay.portal.kernel.search.Indexer;
052 import com.liferay.portal.kernel.search.IndexerPostProcessor;
053 import com.liferay.portal.kernel.search.IndexerRegistryUtil;
054 import com.liferay.portal.kernel.security.pacl.PACLConstants;
055 import com.liferay.portal.kernel.security.pacl.permission.PortalHookPermission;
056 import com.liferay.portal.kernel.servlet.DirectServletRegistryUtil;
057 import com.liferay.portal.kernel.servlet.LiferayFilter;
058 import com.liferay.portal.kernel.servlet.LiferayFilterTracker;
059 import com.liferay.portal.kernel.servlet.ServletContextPool;
060 import com.liferay.portal.kernel.servlet.TryFilter;
061 import com.liferay.portal.kernel.servlet.TryFinallyFilter;
062 import com.liferay.portal.kernel.servlet.WrapHttpServletRequestFilter;
063 import com.liferay.portal.kernel.servlet.WrapHttpServletResponseFilter;
064 import com.liferay.portal.kernel.servlet.filters.invoker.FilterMapping;
065 import com.liferay.portal.kernel.servlet.filters.invoker.InvokerFilterConfig;
066 import com.liferay.portal.kernel.servlet.filters.invoker.InvokerFilterHelper;
067 import com.liferay.portal.kernel.servlet.taglib.FileAvailabilityUtil;
068 import com.liferay.portal.kernel.struts.StrutsAction;
069 import com.liferay.portal.kernel.struts.StrutsPortletAction;
070 import com.liferay.portal.kernel.upgrade.UpgradeException;
071 import com.liferay.portal.kernel.util.CharPool;
072 import com.liferay.portal.kernel.util.FileUtil;
073 import com.liferay.portal.kernel.util.GetterUtil;
074 import com.liferay.portal.kernel.util.HttpUtil;
075 import com.liferay.portal.kernel.util.InstanceFactory;
076 import com.liferay.portal.kernel.util.ListUtil;
077 import com.liferay.portal.kernel.util.LocaleUtil;
078 import com.liferay.portal.kernel.util.PropertiesUtil;
079 import com.liferay.portal.kernel.util.PropsKeys;
080 import com.liferay.portal.kernel.util.ProxyUtil;
081 import com.liferay.portal.kernel.util.SetUtil;
082 import com.liferay.portal.kernel.util.StringBundler;
083 import com.liferay.portal.kernel.util.StringPool;
084 import com.liferay.portal.kernel.util.StringUtil;
085 import com.liferay.portal.kernel.util.UniqueList;
086 import com.liferay.portal.kernel.util.Validator;
087 import com.liferay.portal.kernel.xml.Document;
088 import com.liferay.portal.kernel.xml.Element;
089 import com.liferay.portal.kernel.xml.SAXReaderUtil;
090 import com.liferay.portal.language.LanguageResources;
091 import com.liferay.portal.model.BaseModel;
092 import com.liferay.portal.model.ModelListener;
093 import com.liferay.portal.model.Release;
094 import com.liferay.portal.repository.util.RepositoryFactory;
095 import com.liferay.portal.repository.util.RepositoryFactoryImpl;
096 import com.liferay.portal.repository.util.RepositoryFactoryUtil;
097 import com.liferay.portal.sanitizer.SanitizerImpl;
098 import com.liferay.portal.security.auth.AuthFailure;
099 import com.liferay.portal.security.auth.AuthPipeline;
100 import com.liferay.portal.security.auth.AuthToken;
101 import com.liferay.portal.security.auth.AuthTokenUtil;
102 import com.liferay.portal.security.auth.AuthTokenWrapper;
103 import com.liferay.portal.security.auth.Authenticator;
104 import com.liferay.portal.security.auth.AutoLogin;
105 import com.liferay.portal.security.auth.CompanyThreadLocal;
106 import com.liferay.portal.security.auth.EmailAddressGenerator;
107 import com.liferay.portal.security.auth.EmailAddressGeneratorFactory;
108 import com.liferay.portal.security.auth.EmailAddressValidator;
109 import com.liferay.portal.security.auth.EmailAddressValidatorFactory;
110 import com.liferay.portal.security.auth.FullNameGenerator;
111 import com.liferay.portal.security.auth.FullNameGeneratorFactory;
112 import com.liferay.portal.security.auth.FullNameValidator;
113 import com.liferay.portal.security.auth.FullNameValidatorFactory;
114 import com.liferay.portal.security.auth.ScreenNameGenerator;
115 import com.liferay.portal.security.auth.ScreenNameGeneratorFactory;
116 import com.liferay.portal.security.auth.ScreenNameValidator;
117 import com.liferay.portal.security.auth.ScreenNameValidatorFactory;
118 import com.liferay.portal.security.lang.DoPrivilegedBean;
119 import com.liferay.portal.security.ldap.AttributesTransformer;
120 import com.liferay.portal.security.ldap.AttributesTransformerFactory;
121 import com.liferay.portal.security.pwd.PwdToolkitUtil;
122 import com.liferay.portal.security.pwd.Toolkit;
123 import com.liferay.portal.security.pwd.ToolkitWrapper;
124 import com.liferay.portal.service.ReleaseLocalServiceUtil;
125 import com.liferay.portal.service.persistence.BasePersistence;
126 import com.liferay.portal.servlet.filters.autologin.AutoLoginFilter;
127 import com.liferay.portal.servlet.filters.cache.CacheUtil;
128 import com.liferay.portal.spring.aop.ServiceBeanAopProxy;
129 import com.liferay.portal.struts.AuthPublicPathRegistry;
130 import com.liferay.portal.struts.StrutsActionRegistryUtil;
131 import com.liferay.portal.upgrade.UpgradeProcessUtil;
132 import com.liferay.portal.util.CustomJspRegistryUtil;
133 import com.liferay.portal.util.JavaScriptBundleUtil;
134 import com.liferay.portal.util.PortalInstances;
135 import com.liferay.portal.util.PortalUtil;
136 import com.liferay.portal.util.PropsUtil;
137 import com.liferay.portal.util.PropsValues;
138 import com.liferay.portlet.ControlPanelEntry;
139 import com.liferay.portlet.DefaultControlPanelEntryFactory;
140 import com.liferay.portlet.documentlibrary.antivirus.AntivirusScanner;
141 import com.liferay.portlet.documentlibrary.antivirus.AntivirusScannerUtil;
142 import com.liferay.portlet.documentlibrary.antivirus.AntivirusScannerWrapper;
143 import com.liferay.portlet.documentlibrary.store.Store;
144 import com.liferay.portlet.documentlibrary.store.StoreFactory;
145 import com.liferay.portlet.documentlibrary.util.DLProcessor;
146 import com.liferay.portlet.documentlibrary.util.DLProcessorRegistryUtil;
147
148 import java.io.File;
149 import java.io.InputStream;
150
151 import java.lang.reflect.Constructor;
152 import java.lang.reflect.Field;
153 import java.lang.reflect.InvocationHandler;
154
155 import java.net.URL;
156
157 import java.util.ArrayList;
158 import java.util.HashMap;
159 import java.util.HashSet;
160 import java.util.Iterator;
161 import java.util.List;
162 import java.util.Locale;
163 import java.util.Map;
164 import java.util.Properties;
165 import java.util.Set;
166
167 import javax.servlet.Filter;
168 import javax.servlet.FilterConfig;
169 import javax.servlet.ServletContext;
170
171 import org.springframework.aop.TargetSource;
172 import org.springframework.aop.framework.AdvisedSupport;
173 import org.springframework.aop.target.SingletonTargetSource;
174
175
182 public class HookHotDeployListener
183 extends BaseHotDeployListener implements PropsKeys {
184
185 public static final String[] SUPPORTED_PROPERTIES = {
186 "admin.default.group.names", "admin.default.role.names",
187 "admin.default.user.group.names", "asset.publisher.display.styles",
188 "auth.forward.by.last.path", "auth.public.paths",
189 "auto.deploy.listeners", "application.startup.events", "auth.failure",
190 "auth.max.failures", "auth.token.impl", "auth.pipeline.post",
191 "auth.pipeline.pre", "auto.login.hooks",
192 "captcha.check.portal.create_account", "captcha.engine.impl",
193 "company.default.locale", "company.default.time.zone",
194 "company.settings.form.configuration",
195 "company.settings.form.identification",
196 "company.settings.form.miscellaneous",
197 "control.panel.entry.class.default", "convert.processes",
198 "default.landing.page.path", "dl.file.entry.drafts.enabled",
199 "dl.file.entry.processors", "dl.repository.impl",
200 "dl.store.antivirus.impl", "dl.store.impl", "dockbar.add.portlets",
201 "field.enable.com.liferay.portal.model.Contact.birthday",
202 "field.enable.com.liferay.portal.model.Contact.male",
203 "field.enable.com.liferay.portal.model.Organization.status",
204 "hot.deploy.listeners", "javascript.fast.load",
205 "journal.article.form.add", "journal.article.form.translate",
206 "journal.article.form.update", "layout.form.add", "layout.form.update",
207 "layout.set.form.update", "layout.static.portlets.all",
208 "layout.template.cache.enabled", "layout.types",
209 "layout.user.private.layouts.auto.create",
210 "layout.user.private.layouts.enabled",
211 "layout.user.private.layouts.power.user.required",
212 "layout.user.public.layouts.auto.create",
213 "layout.user.public.layouts.enabled",
214 "layout.user.public.layouts.power.user.required",
215 "ldap.attrs.transformer.impl", "locales", "locales.beta",
216 "lock.listeners", "login.create.account.allow.custom.password",
217 "login.events.post", "login.events.pre", "logout.events.post",
218 "logout.events.pre", "mail.hook.impl",
219 "my.sites.show.private.sites.with.no.layouts",
220 "my.sites.show.public.sites.with.no.layouts",
221 "my.sites.show.user.private.sites.with.no.layouts",
222 "my.sites.show.user.public.sites.with.no.layouts",
223 "organizations.form.add.identification", "organizations.form.add.main",
224 "organizations.form.add.miscellaneous",
225 "passwords.passwordpolicytoolkit.generator",
226 "passwords.passwordpolicytoolkit.static", "phone.number.format.impl",
227 "phone.number.format.international.regexp",
228 "phone.number.format.usa.regexp",
229 "portlet.add.default.resource.check.enabled",
230 "portlet.add.default.resource.check.whitelist",
231 "portlet.add.default.resource.check.whitelist.actions",
232 "sanitizer.impl", "servlet.session.create.events",
233 "servlet.session.destroy.events", "servlet.service.events.post",
234 "servlet.service.events.pre", "session.max.allowed",
235 "session.phishing.protected.attributes", "session.store.password",
236 "sites.form.add.advanced", "sites.form.add.main", "sites.form.add.seo",
237 "sites.form.update.advanced", "sites.form.update.main",
238 "sites.form.update.seo", "social.bookmark.*", "terms.of.use.required",
239 "theme.css.fast.load", "theme.images.fast.load",
240 "theme.jsp.override.enabled", "theme.loader.new.theme.id.on.import",
241 "theme.portlet.decorate.default", "theme.portlet.sharing.default",
242 "theme.shortcut.icon", "time.zones", "upgrade.processes",
243 "user.notification.event.confirmation.enabled",
244 "users.email.address.generator", "users.email.address.validator",
245 "users.email.address.required", "users.form.add.identification",
246 "users.form.add.main", "users.form.add.miscellaneous",
247 "users.form.my.account.identification", "users.form.my.account.main",
248 "users.form.my.account.miscellaneous",
249 "users.form.update.identification", "users.form.update.main",
250 "users.form.update.miscellaneous", "users.full.name.generator",
251 "users.full.name.validator", "users.image.max.height",
252 "users.image.max.width", "users.screen.name.always.autogenerate",
253 "users.screen.name.generator", "users.screen.name.validator",
254 "value.object.listener.*"
255 };
256
257 public HookHotDeployListener() {
258 for (String key : _PROPS_VALUES_MERGE_STRING_ARRAY) {
259 _mergeStringArraysContainerMap.put(
260 key, new MergeStringArraysContainer(key));
261 }
262
263 for (String key : _PROPS_VALUES_OVERRIDE_STRING_ARRAY) {
264 _overrideStringArraysContainerMap.put(
265 key, new OverrideStringArraysContainer(key));
266 }
267 }
268
269 @Override
270 public void invokeDeploy(HotDeployEvent hotDeployEvent)
271 throws HotDeployException {
272
273 try {
274 doInvokeDeploy(hotDeployEvent);
275 }
276 catch (Throwable t) {
277 throwHotDeployException(
278 hotDeployEvent, "Error registering hook for ", t);
279 }
280 }
281
282 @Override
283 public void invokeUndeploy(HotDeployEvent hotDeployEvent)
284 throws HotDeployException {
285
286 try {
287 doInvokeUndeploy(hotDeployEvent);
288 }
289 catch (Throwable t) {
290 throwHotDeployException(
291 hotDeployEvent, "Error unregistering hook for ", t);
292 }
293 }
294
295 protected boolean checkPermission(
296 String name, ClassLoader portletClassLoader, Object subject,
297 String message) {
298
299 try {
300 PortalHookPermission.checkPermission(
301 name, portletClassLoader, subject);
302 }
303 catch (SecurityException se) {
304 if (_log.isInfoEnabled()) {
305 _log.info(message);
306 }
307
308 return false;
309 }
310
311 return true;
312 }
313
314 protected boolean containsKey(Properties portalProperties, String key) {
315 if (_log.isDebugEnabled()) {
316 return true;
317 }
318 else {
319 return portalProperties.containsKey(key);
320 }
321 }
322
323 protected void destroyCustomJspBag(
324 String servletContextName, CustomJspBag customJspBag)
325 throws Exception {
326
327 String customJspDir = customJspBag.getCustomJspDir();
328 boolean customJspGlobal = customJspBag.isCustomJspGlobal();
329 List<String> customJsps = customJspBag.getCustomJsps();
330
331 String portalWebDir = PortalUtil.getPortalWebDir();
332
333 for (String customJsp : customJsps) {
334 int pos = customJsp.indexOf(customJspDir);
335
336 String portalJsp = customJsp.substring(pos + customJspDir.length());
337
338 if (customJspGlobal) {
339 File portalJspFile = new File(portalWebDir + portalJsp);
340 File portalJspBackupFile = getPortalJspBackupFile(
341 portalJspFile);
342
343 if (portalJspBackupFile.exists()) {
344 FileUtil.copyFile(portalJspBackupFile, portalJspFile);
345
346 portalJspBackupFile.delete();
347 }
348 else if (portalJspFile.exists()) {
349 portalJspFile.delete();
350 }
351 }
352 else {
353 portalJsp = CustomJspRegistryUtil.getCustomJspFileName(
354 servletContextName, portalJsp);
355
356 File portalJspFile = new File(portalWebDir + portalJsp);
357
358 if (portalJspFile.exists()) {
359 portalJspFile.delete();
360 }
361 }
362 }
363
364 if (!customJspGlobal) {
365 CustomJspRegistryUtil.unregisterServletContextName(
366 servletContextName);
367 }
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.AUTH_TOKEN_IMPL)) {
388 AuthTokenWrapper authTokenWrapper =
389 (AuthTokenWrapper)AuthTokenUtil.getAuthToken();
390
391 authTokenWrapper.setAuthToken(null);
392 }
393
394 if (portalProperties.containsKey(PropsKeys.CAPTCHA_ENGINE_IMPL)) {
395 CaptchaImpl captchaImpl = null;
396
397 Captcha captcha = CaptchaUtil.getCaptcha();
398
399 if (captcha instanceof DoPrivilegedBean) {
400 DoPrivilegedBean doPrivilegedBean = (DoPrivilegedBean)captcha;
401
402 captchaImpl = (CaptchaImpl)doPrivilegedBean.getActualBean();
403 }
404 else {
405 captchaImpl = (CaptchaImpl)captcha;
406 }
407
408 captchaImpl.setCaptcha(null);
409 }
410
411 if (portalProperties.containsKey(
412 PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS)) {
413
414 DefaultControlPanelEntryFactory.setInstance(null);
415 }
416
417 if (portalProperties.containsKey(PropsKeys.DL_FILE_ENTRY_PROCESSORS)) {
418 DLFileEntryProcessorContainer dlFileEntryProcessorContainer =
419 _dlFileEntryProcessorContainerMap.remove(servletContextName);
420
421 dlFileEntryProcessorContainer.unregisterDLProcessors();
422 }
423
424 if (portalProperties.containsKey(PropsKeys.DL_REPOSITORY_IMPL)) {
425 DLRepositoryContainer dlRepositoryContainer =
426 _dlRepositoryContainerMap.remove(servletContextName);
427
428 dlRepositoryContainer.unregisterRepositoryFactories();
429 }
430
431 if (portalProperties.containsKey(PropsKeys.DL_STORE_ANTIVIRUS_IMPL)) {
432 AntivirusScannerWrapper antivirusScannerWrapper =
433 (AntivirusScannerWrapper)
434 AntivirusScannerUtil.getAntivirusScanner();
435
436 antivirusScannerWrapper.setAntivirusScanner(null);
437 }
438
439 if (portalProperties.containsKey(PropsKeys.DL_STORE_IMPL)) {
440 StoreFactory.setInstance(null);
441 }
442
443 if (portalProperties.containsKey(
444 PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL)) {
445
446 AttributesTransformerFactory.setInstance(null);
447 }
448
449 if (portalProperties.containsKey(LOCK_LISTENERS)) {
450 LockListenerContainer lockListenerContainer =
451 _lockListenerContainerMap.remove(servletContextName);
452
453 if (lockListenerContainer != null) {
454 lockListenerContainer.unregisterLockListeners();
455 }
456 }
457
458 if (portalProperties.containsKey(PropsKeys.MAIL_HOOK_IMPL)) {
459 com.liferay.mail.util.HookFactory.setInstance(null);
460 }
461
462 if (portalProperties.containsKey(PropsKeys.PASSWORDS_TOOLKIT)) {
463 ToolkitWrapper toolkitWrapper =
464 (ToolkitWrapper)PwdToolkitUtil.getToolkit();
465
466 toolkitWrapper.setToolkit(null);
467 }
468
469 if (portalProperties.containsKey(PropsKeys.PHONE_NUMBER_FORMAT_IMPL)) {
470 PhoneNumberFormatWrapper phoneNumberFormatWrapper =
471 (PhoneNumberFormatWrapper)
472 PhoneNumberFormatUtil.getPhoneNumberFormat();
473
474 phoneNumberFormatWrapper.setPhoneNumberFormat(null);
475 }
476
477 if (portalProperties.containsKey(PropsKeys.SANITIZER_IMPL)) {
478 SanitizerContainer sanitizerContainer =
479 _sanitizerContainerMap.remove(servletContextName);
480
481 if (sanitizerContainer != null) {
482 sanitizerContainer.unregisterSanitizers();
483 }
484 }
485
486 if (portalProperties.containsKey(
487 PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR)) {
488
489 EmailAddressGeneratorFactory.setInstance(null);
490 }
491
492 if (portalProperties.containsKey(
493 PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR)) {
494
495 EmailAddressValidatorFactory.setInstance(null);
496 }
497
498 if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_GENERATOR)) {
499 FullNameGeneratorFactory.setInstance(null);
500 }
501
502 if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_VALIDATOR)) {
503 FullNameValidatorFactory.setInstance(null);
504 }
505
506 if (portalProperties.containsKey(
507 PropsKeys.USERS_SCREEN_NAME_GENERATOR)) {
508
509 ScreenNameGeneratorFactory.setInstance(null);
510 }
511
512 if (portalProperties.containsKey(
513 PropsKeys.USERS_SCREEN_NAME_VALIDATOR)) {
514
515 ScreenNameValidatorFactory.setInstance(null);
516 }
517
518 Set<String> liferayFilterClassNames =
519 LiferayFilterTracker.getClassNames();
520
521 for (String liferayFilterClassName : liferayFilterClassNames) {
522 if (!portalProperties.containsKey(liferayFilterClassName)) {
523 continue;
524 }
525
526 boolean filterEnabled = GetterUtil.getBoolean(
527 PropsUtil.get(liferayFilterClassName));
528
529 Set<LiferayFilter> liferayFilters =
530 LiferayFilterTracker.getLiferayFilters(liferayFilterClassName);
531
532 for (LiferayFilter liferayFilter : liferayFilters) {
533 liferayFilter.setFilterEnabled(filterEnabled);
534 }
535 }
536 }
537
538 protected void destroyServices(String servletContextName) throws Exception {
539 Map<String, ServiceBag> serviceBags = _servicesContainer._serviceBags;
540
541 for (Map.Entry<String, ServiceBag> entry : serviceBags.entrySet()) {
542 String serviceType = entry.getKey();
543 ServiceBag serviceBag = entry.getValue();
544
545 Map<String, List<ServiceConstructor>> serviceConstructors =
546 serviceBag._serviceConstructors;
547
548 if (serviceConstructors.remove(servletContextName) == null) {
549 continue;
550 }
551
552 Object serviceProxy = PortalBeanLocatorUtil.locate(serviceType);
553
554 AdvisedSupport advisedSupport = getAdvisedSupport(serviceProxy);
555
556 Object previousService = serviceBag.getCustomService();
557
558 TargetSource previousTargetSource = new SingletonTargetSource(
559 previousService);
560
561 advisedSupport.setTargetSource(previousTargetSource);
562 }
563 }
564
565 protected void doInvokeDeploy(HotDeployEvent hotDeployEvent)
566 throws Exception {
567
568 ServletContext servletContext = hotDeployEvent.getServletContext();
569
570 String servletContextName = servletContext.getServletContextName();
571
572 if (_log.isDebugEnabled()) {
573 _log.debug("Invoking deploy for " + servletContextName);
574 }
575
576 String xml = HttpUtil.URLtoString(
577 servletContext.getResource("/WEB-INF/liferay-hook.xml"));
578
579 if (xml == null) {
580 return;
581 }
582
583 if (_log.isInfoEnabled()) {
584 _log.info("Registering hook for " + servletContextName);
585 }
586
587 _servletContextNames.add(servletContextName);
588
589 Document document = SAXReaderUtil.read(xml, true);
590
591 Element rootElement = document.getRootElement();
592
593 ClassLoader portletClassLoader = hotDeployEvent.getContextClassLoader();
594
595 initPortalProperties(
596 servletContextName, portletClassLoader, rootElement);
597
598 initLanguageProperties(
599 servletContextName, portletClassLoader, rootElement);
600
601 initCustomJspDir(
602 servletContext, servletContextName, portletClassLoader,
603 hotDeployEvent.getPluginPackage(), rootElement);
604
605 initIndexerPostProcessors(
606 servletContextName, portletClassLoader, rootElement);
607
608 List<Element> serviceElements = rootElement.elements("service");
609
610 for (Element serviceElement : serviceElements) {
611 String serviceType = serviceElement.elementText("service-type");
612 String serviceImpl = serviceElement.elementText("service-impl");
613
614 if (!checkPermission(
615 PACLConstants.PORTAL_HOOK_PERMISSION_SERVICE,
616 portletClassLoader, serviceType,
617 "Rejecting service " + serviceImpl)) {
618
619 continue;
620 }
621
622 Class<?> serviceTypeClass = portletClassLoader.loadClass(
623 serviceType);
624 Class<?> serviceImplClass = portletClassLoader.loadClass(
625 serviceImpl);
626
627 Constructor<?> serviceImplConstructor =
628 serviceImplClass.getConstructor(
629 new Class<?>[] {serviceTypeClass});
630
631 Object serviceProxy = PortalBeanLocatorUtil.locate(serviceType);
632
633 if (ProxyUtil.isProxyClass(serviceProxy.getClass())) {
634 initServices(
635 servletContextName, portletClassLoader, serviceType,
636 serviceTypeClass, serviceImplConstructor, serviceProxy);
637 }
638 else {
639 _log.error(
640 "Service hooks require Spring to be configured to use " +
641 "JdkDynamicProxy and will not work with CGLIB");
642 }
643 }
644
645 initServletFilters(
646 servletContext, servletContextName, portletClassLoader,
647 rootElement);
648
649 initStrutsActions(servletContextName, portletClassLoader, rootElement);
650
651
652
653 ModelListenersContainer modelListenersContainer =
654 _modelListenersContainerMap.get(servletContextName);
655
656 if (modelListenersContainer == null) {
657 modelListenersContainer = new ModelListenersContainer();
658
659 _modelListenersContainerMap.put(
660 servletContextName, modelListenersContainer);
661 }
662
663 List<Element> modelListenerElements = rootElement.elements(
664 "model-listener");
665
666 for (Element modelListenerElement : modelListenerElements) {
667 String modelName = modelListenerElement.elementText("model-name");
668 String modelListenerClassName = modelListenerElement.elementText(
669 "model-listener-class");
670
671 ModelListener<BaseModel<?>> modelListener = initModelListener(
672 modelName, modelListenerClassName, portletClassLoader);
673
674 if (modelListener != null) {
675 modelListenersContainer.registerModelListener(
676 modelName, modelListener);
677 }
678 }
679
680 EventsContainer eventsContainer = _eventsContainerMap.get(
681 servletContextName);
682
683 if (eventsContainer == null) {
684 eventsContainer = new EventsContainer();
685
686 _eventsContainerMap.put(servletContextName, eventsContainer);
687 }
688
689 List<Element> eventElements = rootElement.elements("event");
690
691 for (Element eventElement : eventElements) {
692 String eventName = eventElement.elementText("event-type");
693 String eventClassName = eventElement.elementText("event-class");
694
695 Object obj = initEvent(
696 eventName, eventClassName, portletClassLoader);
697
698 if (obj != null) {
699 eventsContainer.registerEvent(eventName, obj);
700 }
701 }
702
703
704
705 registerClpMessageListeners(servletContext, portletClassLoader);
706
707 DirectServletRegistryUtil.clearServlets();
708 FileAvailabilityUtil.reset();
709
710 if (_log.isInfoEnabled()) {
711 _log.info(
712 "Hook for " + servletContextName + " is available for use");
713 }
714 }
715
716 protected void doInvokeUndeploy(HotDeployEvent hotDeployEvent)
717 throws Exception {
718
719 ServletContext servletContext = hotDeployEvent.getServletContext();
720
721 String servletContextName = servletContext.getServletContextName();
722
723 if (_log.isDebugEnabled()) {
724 _log.debug("Invoking undeploy for " + servletContextName);
725 }
726
727 if (!_servletContextNames.remove(servletContextName)) {
728 return;
729 }
730
731 AuthenticatorsContainer authenticatorsContainer =
732 _authenticatorsContainerMap.remove(servletContextName);
733
734 if (authenticatorsContainer != null) {
735 authenticatorsContainer.unregisterAuthenticators();
736 }
737
738 AuthFailuresContainer authFailuresContainer =
739 _authFailuresContainerMap.remove(servletContextName);
740
741 if (authFailuresContainer != null) {
742 authFailuresContainer.unregisterAuthFailures();
743 }
744
745 AuthPublicPathsContainer authPublicPathsContainer =
746 _authPublicPathsContainerMap.remove(servletContextName);
747
748 if (authPublicPathsContainer != null) {
749 authPublicPathsContainer.unregisterPaths();
750 }
751
752 AutoDeployListenersContainer autoDeployListenersContainer =
753 _autoDeployListenersContainerMap.remove(servletContextName);
754
755 if (autoDeployListenersContainer != null) {
756 autoDeployListenersContainer.unregisterAutoDeployListeners();
757 }
758
759 AutoLoginsContainer autoLoginsContainer =
760 _autoLoginsContainerMap.remove(servletContextName);
761
762 if (autoLoginsContainer != null) {
763 autoLoginsContainer.unregisterAutoLogins();
764 }
765
766 CustomJspBag customJspBag = _customJspBagsMap.remove(
767 servletContextName);
768
769 if (customJspBag != null) {
770 destroyCustomJspBag(servletContextName, customJspBag);
771 }
772
773 EventsContainer eventsContainer = _eventsContainerMap.remove(
774 servletContextName);
775
776 if (eventsContainer != null) {
777 eventsContainer.unregisterEvents();
778 }
779
780 HotDeployListenersContainer hotDeployListenersContainer =
781 _hotDeployListenersContainerMap.remove(servletContextName);
782
783 if (hotDeployListenersContainer != null) {
784 hotDeployListenersContainer.unregisterHotDeployListeners();
785 }
786
787 IndexerPostProcessorContainer indexerPostProcessorContainer =
788 _indexerPostProcessorContainerMap.remove(servletContextName);
789
790 if (indexerPostProcessorContainer != null) {
791 indexerPostProcessorContainer.unregisterIndexerPostProcessor();
792 }
793
794 LanguagesContainer languagesContainer = _languagesContainerMap.remove(
795 servletContextName);
796
797 if (languagesContainer != null) {
798 languagesContainer.unregisterLanguages();
799 }
800
801 ModelListenersContainer modelListenersContainer =
802 _modelListenersContainerMap.remove(servletContextName);
803
804 if (modelListenersContainer != null) {
805 modelListenersContainer.unregisterModelListeners();
806 }
807
808 Properties portalProperties = _portalPropertiesMap.remove(
809 servletContextName);
810
811 if (portalProperties != null) {
812 destroyPortalProperties(servletContextName, portalProperties);
813 }
814
815 destroyServices(servletContextName);
816
817 ServletFiltersContainer servletFiltersContainer =
818 _servletFiltersContainerMap.remove(servletContextName);
819
820 if (servletFiltersContainer != null) {
821 servletFiltersContainer.unregisterFilterMappings();
822 }
823
824 StrutsActionsContainer strutsActionContainer =
825 _strutsActionsContainerMap.remove(servletContextName);
826
827 if (strutsActionContainer != null) {
828 strutsActionContainer.unregisterStrutsActions();
829 }
830
831 unregisterClpMessageListeners(servletContext);
832
833 if (_log.isInfoEnabled()) {
834 _log.info("Hook for " + servletContextName + " was unregistered");
835 }
836 }
837
838 protected AdvisedSupport getAdvisedSupport(Object serviceProxy)
839 throws Exception {
840
841 InvocationHandler invocationHandler = ProxyUtil.getInvocationHandler(
842 serviceProxy);
843
844 Class<?> invocationHandlerClass = invocationHandler.getClass();
845
846 Field advisedSupportField = invocationHandlerClass.getDeclaredField(
847 "_advisedSupport");
848
849 advisedSupportField.setAccessible(true);
850
851 return (AdvisedSupport)advisedSupportField.get(invocationHandler);
852 }
853
854 protected void getCustomJsps(
855 ServletContext servletContext, String webDir, String resourcePath,
856 List<String> customJsps) {
857
858 Set<String> resourcePaths = servletContext.getResourcePaths(
859 resourcePath);
860
861 for (String curResourcePath : resourcePaths) {
862 if (curResourcePath.endsWith(StringPool.SLASH)) {
863 getCustomJsps(
864 servletContext, webDir, curResourcePath, customJsps);
865 }
866 else {
867 String customJsp = webDir + curResourcePath;
868
869 customJsp = StringUtil.replace(
870 customJsp, StringPool.DOUBLE_SLASH, StringPool.SLASH);
871
872 customJsps.add(customJsp);
873 }
874 }
875 }
876
877 protected Locale getLocale(String languagePropertiesLocation) {
878 int x = languagePropertiesLocation.indexOf(CharPool.UNDERLINE);
879 int y = languagePropertiesLocation.indexOf(".properties");
880
881 Locale locale = null;
882
883 if ((x != -1) && (y != 1)) {
884 String localeKey = languagePropertiesLocation.substring(x + 1, y);
885
886 locale = LocaleUtil.fromLanguageId(localeKey);
887
888 }
889
890 return locale;
891 }
892
893 protected BasePersistence<?> getPersistence(String modelName) {
894 int pos = modelName.lastIndexOf(CharPool.PERIOD);
895
896 String entityName = modelName.substring(pos + 1);
897
898 pos = modelName.lastIndexOf(".model.");
899
900 String packagePath = modelName.substring(0, pos);
901
902 return (BasePersistence<?>)PortalBeanLocatorUtil.locate(
903 packagePath + ".service.persistence." + entityName + "Persistence");
904 }
905
906 protected File getPortalJspBackupFile(File portalJspFile) {
907 String fileName = portalJspFile.getName();
908 String filePath = portalJspFile.toString();
909
910 int fileNameIndex = fileName.lastIndexOf(CharPool.PERIOD);
911
912 if (fileNameIndex > 0) {
913 int filePathIndex = filePath.lastIndexOf(fileName);
914
915 fileName =
916 fileName.substring(0, fileNameIndex) + ".portal" +
917 fileName.substring(fileNameIndex);
918
919 filePath = filePath.substring(0, filePathIndex) + fileName;
920 }
921 else {
922 filePath += ".portal";
923 }
924
925 return new File(filePath);
926 }
927
928 protected void initAuthenticators(
929 ClassLoader portletClassLoader, Properties portalProperties,
930 String key, AuthenticatorsContainer authenticatorsContainer)
931 throws Exception {
932
933 String[] authenticatorClassNames = StringUtil.split(
934 portalProperties.getProperty(key));
935
936 for (String authenticatorClassName : authenticatorClassNames) {
937 Authenticator authenticator = (Authenticator)newInstance(
938 portletClassLoader, Authenticator.class,
939 authenticatorClassName);
940
941 authenticatorsContainer.registerAuthenticator(key, authenticator);
942 }
943 }
944
945 protected void initAuthenticators(
946 String servletContextName, ClassLoader portletClassLoader,
947 Properties portalProperties)
948 throws Exception {
949
950 AuthenticatorsContainer authenticatorsContainer =
951 new AuthenticatorsContainer();
952
953 _authenticatorsContainerMap.put(
954 servletContextName, authenticatorsContainer);
955
956 initAuthenticators(
957 portletClassLoader, portalProperties, AUTH_PIPELINE_PRE,
958 authenticatorsContainer);
959 initAuthenticators(
960 portletClassLoader, portalProperties, AUTH_PIPELINE_POST,
961 authenticatorsContainer);
962 }
963
964 protected void initAuthFailures(
965 ClassLoader portletClassLoader, Properties portalProperties,
966 String key, AuthFailuresContainer authFailuresContainer)
967 throws Exception {
968
969 String[] authFailureClassNames = StringUtil.split(
970 portalProperties.getProperty(key));
971
972 for (String authFailureClassName : authFailureClassNames) {
973 AuthFailure authFailure = (AuthFailure)newInstance(
974 portletClassLoader, AuthFailure.class, authFailureClassName);
975
976 authFailuresContainer.registerAuthFailure(key, authFailure);
977 }
978 }
979
980 protected void initAuthFailures(
981 String servletContextName, ClassLoader portletClassLoader,
982 Properties portalProperties)
983 throws Exception {
984
985 AuthFailuresContainer authFailuresContainer =
986 new AuthFailuresContainer();
987
988 _authFailuresContainerMap.put(
989 servletContextName, authFailuresContainer);
990
991 initAuthFailures(
992 portletClassLoader, portalProperties, AUTH_FAILURE,
993 authFailuresContainer);
994 initAuthFailures(
995 portletClassLoader, portalProperties, AUTH_MAX_FAILURES,
996 authFailuresContainer);
997 }
998
999 protected void initAuthPublicPaths(
1000 String servletContextName, Properties portalProperties)
1001 throws Exception {
1002
1003 AuthPublicPathsContainer authPublicPathsContainer =
1004 new AuthPublicPathsContainer();
1005
1006 _authPublicPathsContainerMap.put(
1007 servletContextName, authPublicPathsContainer);
1008
1009 String[] publicPaths = StringUtil.split(
1010 portalProperties.getProperty(AUTH_PUBLIC_PATHS));
1011
1012 authPublicPathsContainer.registerPaths(publicPaths);
1013 }
1014
1015 protected void initAutoDeployListeners(
1016 String servletContextName, ClassLoader portletClassLoader,
1017 Properties portalProperties)
1018 throws Exception {
1019
1020 String[] autoDeployListenerClassNames = StringUtil.split(
1021 portalProperties.getProperty(PropsKeys.AUTO_DEPLOY_LISTENERS));
1022
1023 if (autoDeployListenerClassNames.length == 0) {
1024 return;
1025 }
1026
1027 AutoDeployListenersContainer autoDeployListenersContainer =
1028 new AutoDeployListenersContainer();
1029
1030 _autoDeployListenersContainerMap.put(
1031 servletContextName, autoDeployListenersContainer);
1032
1033 for (String autoDeployListenerClassName :
1034 autoDeployListenerClassNames) {
1035
1036 AutoDeployListener autoDeployListener =
1037 (AutoDeployListener)newInstance(
1038 portletClassLoader, AutoDeployListener.class,
1039 autoDeployListenerClassName);
1040
1041 autoDeployListenersContainer.registerAutoDeployListener(
1042 autoDeployListener);
1043 }
1044 }
1045
1046 protected void initAutoLogins(
1047 String servletContextName, ClassLoader portletClassLoader,
1048 Properties portalProperties)
1049 throws Exception {
1050
1051 AutoLoginsContainer autoLoginsContainer = new AutoLoginsContainer();
1052
1053 _autoLoginsContainerMap.put(servletContextName, autoLoginsContainer);
1054
1055 String[] autoLoginClassNames = StringUtil.split(
1056 portalProperties.getProperty(AUTO_LOGIN_HOOKS));
1057
1058 for (String autoLoginClassName : autoLoginClassNames) {
1059 AutoLogin autoLogin = (AutoLogin)newInstance(
1060 portletClassLoader, AutoLogin.class, autoLoginClassName);
1061
1062 autoLoginsContainer.registerAutoLogin(autoLogin);
1063 }
1064 }
1065
1066 protected void initCustomJspBag(
1067 String servletContextName, String displayName,
1068 CustomJspBag customJspBag)
1069 throws Exception {
1070
1071 String customJspDir = customJspBag.getCustomJspDir();
1072 boolean customJspGlobal = customJspBag.isCustomJspGlobal();
1073 List<String> customJsps = customJspBag.getCustomJsps();
1074
1075 String portalWebDir = PortalUtil.getPortalWebDir();
1076
1077 for (String customJsp : customJsps) {
1078 int pos = customJsp.indexOf(customJspDir);
1079
1080 String portalJsp = customJsp.substring(pos + customJspDir.length());
1081
1082 if (customJspGlobal) {
1083 File portalJspFile = new File(portalWebDir + portalJsp);
1084 File portalJspBackupFile = getPortalJspBackupFile(
1085 portalJspFile);
1086
1087 if (portalJspFile.exists() && !portalJspBackupFile.exists()) {
1088 FileUtil.copyFile(portalJspFile, portalJspBackupFile);
1089 }
1090 }
1091 else {
1092 portalJsp = CustomJspRegistryUtil.getCustomJspFileName(
1093 servletContextName, portalJsp);
1094 }
1095
1096 FileUtil.copyFile(customJsp, portalWebDir + portalJsp);
1097 }
1098
1099 if (!customJspGlobal) {
1100 CustomJspRegistryUtil.registerServletContextName(
1101 servletContextName, displayName);
1102 }
1103 }
1104
1105 protected void initCustomJspDir(
1106 ServletContext servletContext, String servletContextName,
1107 ClassLoader portletClassLoader, PluginPackage pluginPackage,
1108 Element rootElement)
1109 throws Exception {
1110
1111 String customJspDir = rootElement.elementText("custom-jsp-dir");
1112
1113 if (Validator.isNull(customJspDir)) {
1114 return;
1115 }
1116
1117 if (!checkPermission(
1118 PACLConstants.PORTAL_HOOK_PERMISSION_CUSTOM_JSP_DIR,
1119 portletClassLoader, null, "Rejecting custom JSP directory")) {
1120
1121 return;
1122 }
1123
1124 if (_log.isDebugEnabled()) {
1125 _log.debug("Custom JSP directory: " + customJspDir);
1126 }
1127
1128 boolean customJspGlobal = GetterUtil.getBoolean(
1129 rootElement.elementText("custom-jsp-global"), true);
1130
1131 List<String> customJsps = new ArrayList<String>();
1132
1133 String webDir = servletContext.getRealPath(StringPool.SLASH);
1134
1135 getCustomJsps(servletContext, webDir, customJspDir, customJsps);
1136
1137 if (customJsps.isEmpty()) {
1138 return;
1139 }
1140
1141 CustomJspBag customJspBag = new CustomJspBag(
1142 customJspDir, customJspGlobal, customJsps);
1143
1144 if (_log.isDebugEnabled()) {
1145 StringBundler sb = new StringBundler(customJsps.size() * 2 + 1);
1146
1147 sb.append("Custom JSP files:\n");
1148
1149 for (String customJsp : customJsps) {
1150 sb.append(customJsp);
1151 sb.append(StringPool.NEW_LINE);
1152 }
1153
1154 sb.setIndex(sb.index() - 1);
1155
1156 _log.debug(sb.toString());
1157 }
1158
1159 _customJspBagsMap.put(servletContextName, customJspBag);
1160
1161 initCustomJspBag(
1162 servletContextName, pluginPackage.getName(), customJspBag);
1163 }
1164
1165 protected Object initEvent(
1166 String eventName, String eventClassName,
1167 ClassLoader portletClassLoader)
1168 throws Exception {
1169
1170 if (eventName.equals(APPLICATION_STARTUP_EVENTS)) {
1171 SimpleAction simpleAction =
1172 (SimpleAction)portletClassLoader.loadClass(
1173 eventClassName).newInstance();
1174
1175 simpleAction = new InvokerSimpleAction(
1176 simpleAction, portletClassLoader);
1177
1178 Long companyId = CompanyThreadLocal.getCompanyId();
1179
1180 try {
1181 long[] companyIds = PortalInstances.getCompanyIds();
1182
1183 for (long curCompanyId : companyIds) {
1184 CompanyThreadLocal.setCompanyId(curCompanyId);
1185
1186 simpleAction.run(
1187 new String[] {String.valueOf(curCompanyId)});
1188 }
1189 }
1190 finally {
1191 CompanyThreadLocal.setCompanyId(companyId);
1192 }
1193
1194 return null;
1195 }
1196
1197 if (_propsKeysEvents.contains(eventName)) {
1198 Action action = (Action)portletClassLoader.loadClass(
1199 eventClassName).newInstance();
1200
1201 action = new InvokerAction(action, portletClassLoader);
1202
1203 EventsProcessorUtil.registerEvent(eventName, action);
1204
1205 return action;
1206 }
1207
1208 if (_propsKeysSessionEvents.contains(eventName)) {
1209 SessionAction sessionAction =
1210 (SessionAction)portletClassLoader.loadClass(
1211 eventClassName).newInstance();
1212
1213 sessionAction = new InvokerSessionAction(
1214 sessionAction, portletClassLoader);
1215
1216 EventsProcessorUtil.registerEvent(eventName, sessionAction);
1217
1218 return sessionAction;
1219 }
1220
1221 return null;
1222 }
1223
1224 protected void initEvents(
1225 String servletContextName, ClassLoader portletClassLoader,
1226 Properties portalProperties)
1227 throws Exception {
1228
1229 EventsContainer eventsContainer = new EventsContainer();
1230
1231 _eventsContainerMap.put(servletContextName, eventsContainer);
1232
1233 for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
1234 String key = (String)entry.getKey();
1235
1236 if (!key.equals(APPLICATION_STARTUP_EVENTS) &&
1237 !_propsKeysEvents.contains(key) &&
1238 !_propsKeysSessionEvents.contains(key)) {
1239
1240 continue;
1241 }
1242
1243 String eventName = key;
1244 String[] eventClassNames = StringUtil.split(
1245 (String)entry.getValue());
1246
1247 for (String eventClassName : eventClassNames) {
1248 Object obj = initEvent(
1249 eventName, eventClassName, portletClassLoader);
1250
1251 if (obj == null) {
1252 continue;
1253 }
1254
1255 eventsContainer.registerEvent(eventName, obj);
1256 }
1257 }
1258 }
1259
1260 protected void initHotDeployListeners(
1261 String servletContextName, ClassLoader portletClassLoader,
1262 Properties portalProperties)
1263 throws Exception {
1264
1265 String[] hotDeployListenerClassNames = StringUtil.split(
1266 portalProperties.getProperty(PropsKeys.HOT_DEPLOY_LISTENERS));
1267
1268 if (hotDeployListenerClassNames.length == 0) {
1269 return;
1270 }
1271
1272 HotDeployListenersContainer hotDeployListenersContainer =
1273 new HotDeployListenersContainer();
1274
1275 _hotDeployListenersContainerMap.put(
1276 servletContextName, hotDeployListenersContainer);
1277
1278 for (String hotDeployListenerClassName : hotDeployListenerClassNames) {
1279 HotDeployListener hotDeployListener =
1280 (HotDeployListener)newInstance(
1281 portletClassLoader, HotDeployListener.class,
1282 hotDeployListenerClassName);
1283
1284 hotDeployListenersContainer.registerHotDeployListener(
1285 hotDeployListener);
1286 }
1287 }
1288
1289 protected void initIndexerPostProcessors(
1290 String servletContextName, ClassLoader portletClassLoader,
1291 Element parentElement)
1292 throws Exception {
1293
1294 IndexerPostProcessorContainer indexerPostProcessorContainer =
1295 _indexerPostProcessorContainerMap.get(servletContextName);
1296
1297 if (indexerPostProcessorContainer == null) {
1298 indexerPostProcessorContainer = new IndexerPostProcessorContainer();
1299
1300 _indexerPostProcessorContainerMap.put(
1301 servletContextName, indexerPostProcessorContainer);
1302 }
1303
1304 List<Element> indexerPostProcessorElements = parentElement.elements(
1305 "indexer-post-processor");
1306
1307 for (Element indexerPostProcessorElement :
1308 indexerPostProcessorElements) {
1309
1310 String indexerClassName = indexerPostProcessorElement.elementText(
1311 "indexer-class-name");
1312
1313 if (!checkPermission(
1314 PACLConstants.PORTAL_HOOK_PERMISSION_INDEXER,
1315 portletClassLoader, indexerClassName,
1316 "Rejecting indexer " + indexerClassName)) {
1317
1318 continue;
1319 }
1320
1321 String indexerPostProcessorImpl =
1322 indexerPostProcessorElement.elementText(
1323 "indexer-post-processor-impl");
1324
1325 Indexer indexer = IndexerRegistryUtil.getIndexer(indexerClassName);
1326
1327 if (indexer == null) {
1328 _log.error("No indexer for " + indexerClassName + " was found");
1329
1330 continue;
1331 }
1332
1333 IndexerPostProcessor indexerPostProcessor =
1334 (IndexerPostProcessor)InstanceFactory.newInstance(
1335 portletClassLoader, indexerPostProcessorImpl);
1336
1337 indexer.registerIndexerPostProcessor(indexerPostProcessor);
1338
1339 indexerPostProcessorContainer.registerIndexerPostProcessor(
1340 indexerClassName, indexerPostProcessor);
1341 }
1342 }
1343
1344 protected void initLanguageProperties(
1345 String servletContextName, ClassLoader portletClassLoader,
1346 Element parentElement)
1347 throws Exception {
1348
1349 LanguagesContainer languagesContainer = new LanguagesContainer();
1350
1351 _languagesContainerMap.put(servletContextName, languagesContainer);
1352
1353 List<Element> languagePropertiesElements = parentElement.elements(
1354 "language-properties");
1355
1356 Map<String, String> baseLanguageMap = null;
1357
1358 for (Element languagePropertiesElement : languagePropertiesElements) {
1359 Properties properties = null;
1360
1361 String languagePropertiesLocation =
1362 languagePropertiesElement.getText();
1363
1364 Locale locale = getLocale(languagePropertiesLocation);
1365
1366 if (locale != null) {
1367 if (!checkPermission(
1368 PACLConstants.
1369 PORTAL_HOOK_PERMISSION_LANGUAGE_PROPERTIES_LOCALE,
1370 portletClassLoader, locale,
1371 "Rejecting locale " + locale)) {
1372
1373 continue;
1374 }
1375 }
1376
1377 try {
1378 URL url = portletClassLoader.getResource(
1379 languagePropertiesLocation);
1380
1381 if (url == null) {
1382 continue;
1383 }
1384
1385 InputStream is = url.openStream();
1386
1387 properties = PropertiesUtil.load(is, StringPool.UTF8);
1388
1389 is.close();
1390 }
1391 catch (Exception e) {
1392 _log.error("Unable to read " + languagePropertiesLocation, e);
1393
1394 continue;
1395 }
1396
1397 Map<String, String> languageMap = new HashMap<String, String>();
1398
1399 if (baseLanguageMap != null) {
1400 languageMap.putAll(baseLanguageMap);
1401 }
1402
1403 for (Map.Entry<Object, Object> entry : properties.entrySet()) {
1404 String key = (String)entry.getKey();
1405 String value = (String)entry.getValue();
1406
1407 value = LanguageResources.fixValue(value);
1408
1409 languageMap.put(key, value);
1410 }
1411
1412 if (locale != null) {
1413 languagesContainer.addLanguage(locale, languageMap);
1414 }
1415 else if (!languageMap.isEmpty()) {
1416 baseLanguageMap = languageMap;
1417 }
1418 }
1419
1420 if (baseLanguageMap != null) {
1421 Locale locale = new Locale(StringPool.BLANK);
1422
1423 languagesContainer.addLanguage(locale, baseLanguageMap);
1424 }
1425 }
1426
1427 @SuppressWarnings("rawtypes")
1428 protected ModelListener<BaseModel<?>> initModelListener(
1429 String modelName, String modelListenerClassName,
1430 ClassLoader portletClassLoader)
1431 throws Exception {
1432
1433 ModelListener<BaseModel<?>> modelListener =
1434 (ModelListener<BaseModel<?>>)newInstance(
1435 portletClassLoader, ModelListener.class,
1436 modelListenerClassName);
1437
1438 BasePersistence persistence = getPersistence(modelName);
1439
1440 persistence.registerListener(modelListener);
1441
1442 return modelListener;
1443 }
1444
1445 protected void initModelListeners(
1446 String servletContextName, ClassLoader portletClassLoader,
1447 Properties portalProperties)
1448 throws Exception {
1449
1450 ModelListenersContainer modelListenersContainer =
1451 new ModelListenersContainer();
1452
1453 _modelListenersContainerMap.put(
1454 servletContextName, modelListenersContainer);
1455
1456 for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
1457 String key = (String)entry.getKey();
1458
1459 if (!key.startsWith(VALUE_OBJECT_LISTENER)) {
1460 continue;
1461 }
1462
1463 String modelName = key.substring(VALUE_OBJECT_LISTENER.length());
1464
1465 String[] modelListenerClassNames = StringUtil.split(
1466 (String)entry.getValue());
1467
1468 for (String modelListenerClassName : modelListenerClassNames) {
1469 ModelListener<BaseModel<?>> modelListener = initModelListener(
1470 modelName, modelListenerClassName, portletClassLoader);
1471
1472 if (modelListener != null) {
1473 modelListenersContainer.registerModelListener(
1474 modelName, modelListener);
1475 }
1476 }
1477 }
1478 }
1479
1480 protected void initPortalProperties(
1481 String servletContextName, ClassLoader portletClassLoader,
1482 Element parentElement)
1483 throws Exception {
1484
1485 String portalPropertiesLocation = parentElement.elementText(
1486 "portal-properties");
1487
1488 if (Validator.isNull(portalPropertiesLocation)) {
1489 return;
1490 }
1491
1492 Configuration portalPropertiesConfiguration = null;
1493
1494 try {
1495 String name = portalPropertiesLocation;
1496
1497 int pos = name.lastIndexOf(".properties");
1498
1499 if (pos != -1) {
1500 name = name.substring(0, pos);
1501 }
1502
1503 portalPropertiesConfiguration =
1504 ConfigurationFactoryUtil.getConfiguration(
1505 portletClassLoader, name);
1506 }
1507 catch (Exception e) {
1508 _log.error("Unable to read " + portalPropertiesLocation, e);
1509 }
1510
1511 if (portalPropertiesConfiguration == null) {
1512 return;
1513 }
1514
1515 Properties portalProperties =
1516 portalPropertiesConfiguration.getProperties();
1517
1518 if (portalProperties.isEmpty()) {
1519 return;
1520 }
1521
1522 Set<Object> set = portalProperties.keySet();
1523
1524 Iterator<Object> iterator = set.iterator();
1525
1526 while (iterator.hasNext()) {
1527 String key = (String)iterator.next();
1528
1529 if (!checkPermission(
1530 PACLConstants.PORTAL_HOOK_PERMISSION_PORTAL_PROPERTIES_KEY,
1531 portletClassLoader, key,
1532 "Rejecting portal.properties key " + key)) {
1533
1534 iterator.remove();
1535 }
1536 }
1537
1538 Properties unfilteredPortalProperties =
1539 (Properties)portalProperties.clone();
1540
1541 portalProperties.remove(PropsKeys.RELEASE_INFO_BUILD_NUMBER);
1542 portalProperties.remove(PropsKeys.RELEASE_INFO_PREVIOUS_BUILD_NUMBER);
1543 portalProperties.remove(PropsKeys.UPGRADE_PROCESSES);
1544
1545 _portalPropertiesMap.put(servletContextName, portalProperties);
1546
1547
1548
1549
1550
1551 initPortalProperties(
1552 servletContextName, portletClassLoader, portalProperties,
1553 unfilteredPortalProperties);
1554 initAuthFailures(
1555 servletContextName, portletClassLoader, portalProperties);
1556 initAutoDeployListeners(
1557 servletContextName, portletClassLoader, portalProperties);
1558 initAutoLogins(
1559 servletContextName, portletClassLoader, portalProperties);
1560 initAuthenticators(
1561 servletContextName, portletClassLoader, portalProperties);
1562 initHotDeployListeners(
1563 servletContextName, portletClassLoader, portalProperties);
1564 initModelListeners(
1565 servletContextName, portletClassLoader, portalProperties);
1566 initEvents(servletContextName, portletClassLoader, portalProperties);
1567 }
1568
1569 protected void initPortalProperties(
1570 String servletContextName, ClassLoader portletClassLoader,
1571 Properties portalProperties, Properties unfilteredPortalProperties)
1572 throws Exception {
1573
1574 PropsUtil.addProperties(portalProperties);
1575
1576 if (_log.isDebugEnabled() && portalProperties.containsKey(LOCALES)) {
1577 _log.debug(
1578 "Portlet locales " + portalProperties.getProperty(LOCALES));
1579 _log.debug("Merged locales " + PropsUtil.get(LOCALES));
1580 _log.debug(
1581 "Merged locales array length " +
1582 PropsUtil.getArray(LOCALES).length);
1583 }
1584
1585 for (String key : _PROPS_VALUES_OBSOLETE) {
1586 if (_log.isInfoEnabled() && portalProperties.contains(key)) {
1587 _log.info("Portal property \"" + key + "\" is obsolete");
1588 }
1589 }
1590
1591 resetPortalProperties(servletContextName, portalProperties, true);
1592
1593 if (portalProperties.containsKey(PropsKeys.AUTH_PUBLIC_PATHS)) {
1594 initAuthPublicPaths(servletContextName, portalProperties);
1595 }
1596
1597 if (portalProperties.containsKey(PropsKeys.AUTH_TOKEN_IMPL)) {
1598 String authTokenClassName = portalProperties.getProperty(
1599 PropsKeys.AUTH_TOKEN_IMPL);
1600
1601 AuthToken authToken = (AuthToken)newInstance(
1602 portletClassLoader, AuthToken.class, authTokenClassName);
1603
1604 AuthTokenWrapper authTokenWrapper =
1605 (AuthTokenWrapper)AuthTokenUtil.getAuthToken();
1606
1607 authTokenWrapper.setAuthToken(authToken);
1608 }
1609
1610 if (portalProperties.containsKey(PropsKeys.CAPTCHA_ENGINE_IMPL)) {
1611 String captchaClassName = portalProperties.getProperty(
1612 PropsKeys.CAPTCHA_ENGINE_IMPL);
1613
1614 Captcha captcha = (Captcha)newInstance(
1615 portletClassLoader, Captcha.class, captchaClassName);
1616
1617 CaptchaImpl captchaImpl = null;
1618
1619 Captcha currentCaptcha = CaptchaUtil.getCaptcha();
1620
1621 if (currentCaptcha instanceof DoPrivilegedBean) {
1622 DoPrivilegedBean doPrivilegedBean =
1623 (DoPrivilegedBean)currentCaptcha;
1624
1625 captchaImpl = (CaptchaImpl)doPrivilegedBean.getActualBean();
1626 }
1627 else {
1628 captchaImpl = (CaptchaImpl)currentCaptcha;
1629 }
1630
1631 captchaImpl.setCaptcha(captcha);
1632 }
1633
1634 if (portalProperties.containsKey(
1635 PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS)) {
1636
1637 String controlPanelEntryClassName = portalProperties.getProperty(
1638 PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS);
1639
1640 ControlPanelEntry controlPanelEntry =
1641 (ControlPanelEntry)newInstance(
1642 portletClassLoader, ControlPanelEntry.class,
1643 controlPanelEntryClassName);
1644
1645 DefaultControlPanelEntryFactory.setInstance(controlPanelEntry);
1646 }
1647
1648 if (portalProperties.containsKey(PropsKeys.DL_FILE_ENTRY_PROCESSORS)) {
1649 String[] dlProcessorClassNames = StringUtil.split(
1650 portalProperties.getProperty(
1651 PropsKeys.DL_FILE_ENTRY_PROCESSORS));
1652
1653 DLFileEntryProcessorContainer dlFileEntryProcessorContainer =
1654 new DLFileEntryProcessorContainer();
1655
1656 _dlFileEntryProcessorContainerMap.put(
1657 servletContextName, dlFileEntryProcessorContainer);
1658
1659 for (String dlProcessorClassName : dlProcessorClassNames) {
1660 DLProcessor dlProcessor = (DLProcessor)newInstance(
1661 portletClassLoader, DLProcessor.class,
1662 dlProcessorClassName);
1663
1664 dlFileEntryProcessorContainer.registerDLProcessor(dlProcessor);
1665 }
1666 }
1667
1668 if (portalProperties.containsKey(PropsKeys.DL_REPOSITORY_IMPL)) {
1669 String[] dlRepositoryClassNames = StringUtil.split(
1670 portalProperties.getProperty(PropsKeys.DL_REPOSITORY_IMPL));
1671
1672 DLRepositoryContainer dlRepositoryContainer =
1673 new DLRepositoryContainer();
1674
1675 _dlRepositoryContainerMap.put(
1676 servletContextName, dlRepositoryContainer);
1677
1678 for (String dlRepositoryClassName : dlRepositoryClassNames) {
1679 RepositoryFactory repositoryFactory = new RepositoryFactoryImpl(
1680 dlRepositoryClassName, portletClassLoader);
1681
1682 dlRepositoryContainer.registerRepositoryFactory(
1683 dlRepositoryClassName, repositoryFactory);
1684 }
1685 }
1686
1687 if (portalProperties.containsKey(PropsKeys.DL_STORE_ANTIVIRUS_IMPL)) {
1688 String antivirusScannerClassName = portalProperties.getProperty(
1689 PropsKeys.DL_STORE_ANTIVIRUS_IMPL);
1690
1691 AntivirusScanner antivirusScanner = (AntivirusScanner)newInstance(
1692 portletClassLoader, AntivirusScanner.class,
1693 antivirusScannerClassName);
1694
1695 AntivirusScannerWrapper antivirusScannerWrapper =
1696 (AntivirusScannerWrapper)
1697 AntivirusScannerUtil.getAntivirusScanner();
1698
1699 antivirusScannerWrapper.setAntivirusScanner(antivirusScanner);
1700 }
1701
1702 if (portalProperties.containsKey(PropsKeys.DL_STORE_IMPL)) {
1703 String storeClassName = portalProperties.getProperty(
1704 PropsKeys.DL_STORE_IMPL);
1705
1706 Store store = (Store)newInstance(
1707 portletClassLoader, Store.class, storeClassName);
1708
1709 StoreFactory.setInstance(store);
1710 }
1711
1712 if (portalProperties.containsKey(
1713 PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL)) {
1714
1715 String attributesTransformerClassName =
1716 portalProperties.getProperty(
1717 PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL);
1718
1719 AttributesTransformer attributesTransformer =
1720 (AttributesTransformer)newInstance(
1721 portletClassLoader, AttributesTransformer.class,
1722 attributesTransformerClassName);
1723
1724 AttributesTransformerFactory.setInstance(attributesTransformer);
1725 }
1726
1727 if (portalProperties.containsKey(LOCK_LISTENERS)) {
1728 LockListenerContainer lockListenerContainer =
1729 _lockListenerContainerMap.get(servletContextName);
1730
1731 if (lockListenerContainer == null) {
1732 lockListenerContainer = new LockListenerContainer();
1733
1734 _lockListenerContainerMap.put(
1735 servletContextName, lockListenerContainer);
1736 }
1737
1738 String[] lockListenerClassNames = StringUtil.split(
1739 portalProperties.getProperty(LOCK_LISTENERS));
1740
1741 for (String lockListenerClassName : lockListenerClassNames) {
1742 LockListener lockListener = (LockListener)newInstance(
1743 portletClassLoader, LockListener.class,
1744 lockListenerClassName);
1745
1746 lockListenerContainer.registerLockListener(lockListener);
1747 }
1748 }
1749
1750 if (portalProperties.containsKey(PropsKeys.MAIL_HOOK_IMPL)) {
1751 String mailHookClassName = portalProperties.getProperty(
1752 PropsKeys.MAIL_HOOK_IMPL);
1753
1754 com.liferay.mail.util.Hook mailHook =
1755 (com.liferay.mail.util.Hook)newInstance(
1756 portletClassLoader, com.liferay.mail.util.Hook.class,
1757 mailHookClassName);
1758
1759 com.liferay.mail.util.HookFactory.setInstance(mailHook);
1760 }
1761
1762 if (portalProperties.containsKey(PropsKeys.PASSWORDS_TOOLKIT)) {
1763 String toolkitClassName = portalProperties.getProperty(
1764 PropsKeys.PASSWORDS_TOOLKIT);
1765
1766 Toolkit toolkit = (Toolkit)newInstance(
1767 portletClassLoader, Sanitizer.class, toolkitClassName);
1768
1769 ToolkitWrapper toolkitWrapper =
1770 (ToolkitWrapper)PwdToolkitUtil.getToolkit();
1771
1772 toolkitWrapper.setToolkit(toolkit);
1773 }
1774
1775 if (portalProperties.containsKey(PropsKeys.PHONE_NUMBER_FORMAT_IMPL)) {
1776 String phoneNumberFormatClassName = portalProperties.getProperty(
1777 PropsKeys.PHONE_NUMBER_FORMAT_IMPL);
1778
1779 PhoneNumberFormat phoneNumberFormat =
1780 (PhoneNumberFormat)newInstance(
1781 portletClassLoader, PhoneNumberFormat.class,
1782 phoneNumberFormatClassName);
1783
1784 PhoneNumberFormatWrapper phoneNumberFormatWrapper =
1785 (PhoneNumberFormatWrapper)
1786 PhoneNumberFormatUtil.getPhoneNumberFormat();
1787
1788 phoneNumberFormatWrapper.setPhoneNumberFormat(phoneNumberFormat);
1789 }
1790
1791 if (portalProperties.containsKey(PropsKeys.SANITIZER_IMPL)) {
1792 String[] sanitizerClassNames = StringUtil.split(
1793 portalProperties.getProperty(PropsKeys.SANITIZER_IMPL));
1794
1795 SanitizerContainer sanitizerContainer = new SanitizerContainer();
1796
1797 _sanitizerContainerMap.put(servletContextName, sanitizerContainer);
1798
1799 for (String sanitizerClassName : sanitizerClassNames) {
1800 Sanitizer sanitizer = (Sanitizer)newInstance(
1801 portletClassLoader, Sanitizer.class, sanitizerClassName);
1802
1803 sanitizerContainer.registerSanitizer(sanitizer);
1804 }
1805 }
1806
1807 if (portalProperties.containsKey(
1808 PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR)) {
1809
1810 String emailAddressGeneratorClassName =
1811 portalProperties.getProperty(
1812 PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR);
1813
1814 EmailAddressGenerator emailAddressGenerator =
1815 (EmailAddressGenerator)newInstance(
1816 portletClassLoader, EmailAddressGenerator.class,
1817 emailAddressGeneratorClassName);
1818
1819 EmailAddressGeneratorFactory.setInstance(emailAddressGenerator);
1820 }
1821
1822 if (portalProperties.containsKey(
1823 PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR)) {
1824
1825 String emailAddressValidatorClassName =
1826 portalProperties.getProperty(
1827 PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR);
1828
1829 EmailAddressValidator emailAddressValidator =
1830 (EmailAddressValidator)newInstance(
1831 portletClassLoader, EmailAddressValidator.class,
1832 emailAddressValidatorClassName);
1833
1834 EmailAddressValidatorFactory.setInstance(emailAddressValidator);
1835 }
1836
1837 if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_GENERATOR)) {
1838 String fullNameGeneratorClassName = portalProperties.getProperty(
1839 PropsKeys.USERS_FULL_NAME_GENERATOR);
1840
1841 FullNameGenerator fullNameGenerator =
1842 (FullNameGenerator)newInstance(
1843 portletClassLoader, FullNameGenerator.class,
1844 fullNameGeneratorClassName);
1845
1846 FullNameGeneratorFactory.setInstance(fullNameGenerator);
1847 }
1848
1849 if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_VALIDATOR)) {
1850 String fullNameValidatorClassName = portalProperties.getProperty(
1851 PropsKeys.USERS_FULL_NAME_VALIDATOR);
1852
1853 FullNameValidator fullNameValidator =
1854 (FullNameValidator)newInstance(
1855 portletClassLoader, FullNameValidator.class,
1856 fullNameValidatorClassName);
1857
1858 FullNameValidatorFactory.setInstance(fullNameValidator);
1859 }
1860
1861 if (portalProperties.containsKey(
1862 PropsKeys.USERS_SCREEN_NAME_GENERATOR)) {
1863
1864 String screenNameGeneratorClassName = portalProperties.getProperty(
1865 PropsKeys.USERS_SCREEN_NAME_GENERATOR);
1866
1867 ScreenNameGenerator screenNameGenerator =
1868 (ScreenNameGenerator)newInstance(
1869 portletClassLoader, ScreenNameGenerator.class,
1870 screenNameGeneratorClassName);
1871
1872 ScreenNameGeneratorFactory.setInstance(screenNameGenerator);
1873 }
1874
1875 if (portalProperties.containsKey(
1876 PropsKeys.USERS_SCREEN_NAME_VALIDATOR)) {
1877
1878 String screenNameValidatorClassName = portalProperties.getProperty(
1879 PropsKeys.USERS_SCREEN_NAME_VALIDATOR);
1880
1881 ScreenNameValidator screenNameValidator =
1882 (ScreenNameValidator)newInstance(
1883 portletClassLoader, ScreenNameValidator.class,
1884 screenNameValidatorClassName);
1885
1886 ScreenNameValidatorFactory.setInstance(screenNameValidator);
1887 }
1888
1889 Set<String> liferayFilterClassNames =
1890 LiferayFilterTracker.getClassNames();
1891
1892 for (String liferayFilterClassName : liferayFilterClassNames) {
1893 if (!portalProperties.containsKey(liferayFilterClassName)) {
1894 continue;
1895 }
1896
1897 boolean filterEnabled = GetterUtil.getBoolean(
1898 portalProperties.getProperty(liferayFilterClassName));
1899
1900 Set<LiferayFilter> liferayFilters =
1901 LiferayFilterTracker.getLiferayFilters(liferayFilterClassName);
1902
1903 for (LiferayFilter liferayFilter : liferayFilters) {
1904 liferayFilter.setFilterEnabled(filterEnabled);
1905 }
1906 }
1907
1908 if (unfilteredPortalProperties.containsKey(
1909 PropsKeys.RELEASE_INFO_BUILD_NUMBER) ||
1910 unfilteredPortalProperties.containsKey(
1911 PropsKeys.UPGRADE_PROCESSES)) {
1912
1913 updateRelease(
1914 servletContextName, portletClassLoader,
1915 unfilteredPortalProperties);
1916 }
1917 }
1918
1919 protected void initServices(
1920 String servletContextName, ClassLoader portletClassLoader,
1921 String serviceType, Class<?> serviceTypeClass,
1922 Constructor<?> serviceImplConstructor, Object serviceProxy)
1923 throws Exception {
1924
1925 AdvisedSupport advisedSupport = getAdvisedSupport(serviceProxy);
1926
1927 TargetSource targetSource = advisedSupport.getTargetSource();
1928
1929 Object previousService = targetSource.getTarget();
1930
1931 if (ProxyUtil.isProxyClass(previousService.getClass())) {
1932 InvocationHandler invocationHandler =
1933 ProxyUtil.getInvocationHandler(previousService);
1934
1935 if (invocationHandler instanceof ClassLoaderBeanHandler) {
1936 ClassLoaderBeanHandler classLoaderBeanHandler =
1937 (ClassLoaderBeanHandler)invocationHandler;
1938
1939 previousService = classLoaderBeanHandler.getBean();
1940 }
1941 }
1942
1943 Object nextService = serviceImplConstructor.newInstance(
1944 previousService);
1945
1946 Object nextTarget = ProxyUtil.newProxyInstance(
1947 portletClassLoader, new Class<?>[] {serviceTypeClass},
1948 new ClassLoaderBeanHandler(nextService, portletClassLoader));
1949
1950 TargetSource nextTargetSource = new SingletonTargetSource(nextTarget);
1951
1952 advisedSupport.setTargetSource(nextTargetSource);
1953
1954 _servicesContainer.addServiceBag(
1955 servletContextName, portletClassLoader, serviceType,
1956 serviceTypeClass, serviceImplConstructor, previousService);
1957
1958 ServiceBeanAopProxy.clearMethodInterceptorCache();
1959 }
1960
1961 protected Filter initServletFilter(
1962 String filterClassName, ClassLoader portletClassLoader)
1963 throws Exception {
1964
1965 Filter filter = (Filter)InstanceFactory.newInstance(
1966 portletClassLoader, filterClassName);
1967
1968 List<Class<?>> interfaces = new ArrayList<Class<?>>();
1969
1970 if (filter instanceof TryFilter) {
1971 interfaces.add(TryFilter.class);
1972 }
1973
1974 if (filter instanceof TryFinallyFilter) {
1975 interfaces.add(TryFinallyFilter.class);
1976 }
1977
1978 if (filter instanceof WrapHttpServletRequestFilter) {
1979 interfaces.add(WrapHttpServletRequestFilter.class);
1980 }
1981
1982 if (filter instanceof WrapHttpServletResponseFilter) {
1983 interfaces.add(WrapHttpServletResponseFilter.class);
1984 }
1985
1986 if (filter instanceof LiferayFilter) {
1987 interfaces.add(LiferayFilter.class);
1988 }
1989 else {
1990 interfaces.add(Filter.class);
1991 }
1992
1993 filter = (Filter)ProxyUtil.newProxyInstance(
1994 portletClassLoader,
1995 interfaces.toArray(new Class[interfaces.size()]),
1996 new ClassLoaderBeanHandler(filter, portletClassLoader));
1997
1998 return filter;
1999 }
2000
2001 protected void initServletFilters(
2002 ServletContext servletContext, String servletContextName,
2003 ClassLoader portletClassLoader, Element parentElement)
2004 throws Exception {
2005
2006 ServletFiltersContainer servletFiltersContainer =
2007 _servletFiltersContainerMap.get(servletContextName);
2008
2009 if (servletFiltersContainer == null) {
2010 servletFiltersContainer = new ServletFiltersContainer();
2011
2012 _servletFiltersContainerMap.put(
2013 servletContextName, servletFiltersContainer);
2014 }
2015
2016 List<Element> servletFilterElements = parentElement.elements(
2017 "servlet-filter");
2018
2019 if (!servletFilterElements.isEmpty() &&
2020 !checkPermission(
2021 PACLConstants.PORTAL_HOOK_PERMISSION_SERVLET_FILTERS,
2022 portletClassLoader, null, "Rejecting servlet filters")) {
2023
2024 return;
2025 }
2026
2027 for (Element servletFilterElement : servletFilterElements) {
2028 String servletFilterName = servletFilterElement.elementText(
2029 "servlet-filter-name");
2030 String servletFilterImpl = servletFilterElement.elementText(
2031 "servlet-filter-impl");
2032
2033 List<Element> initParamElements = servletFilterElement.elements(
2034 "init-param");
2035
2036 Map<String, String> initParameterMap =
2037 new HashMap<String, String>();
2038
2039 for (Element initParamElement : initParamElements) {
2040 String paramName = initParamElement.elementText("param-name");
2041 String paramValue = initParamElement.elementText("param-value");
2042
2043 initParameterMap.put(paramName, paramValue);
2044 }
2045
2046 Filter filter = initServletFilter(
2047 servletFilterImpl, portletClassLoader);
2048
2049 FilterConfig filterConfig = new InvokerFilterConfig(
2050 servletContext, servletFilterName, initParameterMap);
2051
2052 filter.init(filterConfig);
2053
2054 servletFiltersContainer.registerFilter(
2055 servletFilterName, filter, filterConfig);
2056 }
2057
2058 List<Element> servletFilterMappingElements = parentElement.elements(
2059 "servlet-filter-mapping");
2060
2061 for (Element servletFilterMappingElement :
2062 servletFilterMappingElements) {
2063
2064 String servletFilterName = servletFilterMappingElement.elementText(
2065 "servlet-filter-name");
2066 String afterFilter = servletFilterMappingElement.elementText(
2067 "after-filter");
2068 String beforeFilter = servletFilterMappingElement.elementText(
2069 "before-filter");
2070
2071 String positionFilterName = beforeFilter;
2072 boolean after = false;
2073
2074 if (Validator.isNotNull(afterFilter)) {
2075 positionFilterName = afterFilter;
2076 after = true;
2077 }
2078
2079 List<Element> urlPatternElements =
2080 servletFilterMappingElement.elements("url-pattern");
2081
2082 List<String> urlPatterns = new ArrayList<String>();
2083
2084 for (Element urlPatternElement : urlPatternElements) {
2085 String urlPattern = urlPatternElement.getTextTrim();
2086
2087 urlPatterns.add(urlPattern);
2088 }
2089
2090 List<Element> dispatcherElements =
2091 servletFilterMappingElement.elements("dispatcher");
2092
2093 List<String> dispatchers = new ArrayList<String>();
2094
2095 for (Element dispatcherElement : dispatcherElements) {
2096 String dispatcher = dispatcherElement.getTextTrim();
2097
2098 dispatcher = dispatcher.toUpperCase();
2099
2100 dispatchers.add(dispatcher);
2101 }
2102
2103 servletFiltersContainer.registerFilterMapping(
2104 servletFilterName, urlPatterns, dispatchers, positionFilterName,
2105 after);
2106 }
2107 }
2108
2109 protected Object initStrutsAction(
2110 String strutsActionClassName, ClassLoader portletClassLoader)
2111 throws Exception {
2112
2113 Object strutsAction = InstanceFactory.newInstance(
2114 portletClassLoader, strutsActionClassName);
2115
2116 if (strutsAction instanceof StrutsAction) {
2117 return ProxyUtil.newProxyInstance(
2118 portletClassLoader, new Class[] {StrutsAction.class},
2119 new ClassLoaderBeanHandler(strutsAction, portletClassLoader));
2120 }
2121 else {
2122 return ProxyUtil.newProxyInstance(
2123 portletClassLoader, new Class[] {StrutsPortletAction.class},
2124 new ClassLoaderBeanHandler(strutsAction, portletClassLoader));
2125 }
2126 }
2127
2128 protected void initStrutsActions(
2129 String servletContextName, ClassLoader portletClassLoader,
2130 Element parentElement)
2131 throws Exception {
2132
2133 StrutsActionsContainer strutsActionContainer =
2134 _strutsActionsContainerMap.get(servletContextName);
2135
2136 if (strutsActionContainer == null) {
2137 strutsActionContainer = new StrutsActionsContainer();
2138
2139 _strutsActionsContainerMap.put(
2140 servletContextName, strutsActionContainer);
2141 }
2142
2143 List<Element> strutsActionElements = parentElement.elements(
2144 "struts-action");
2145
2146 for (Element strutsActionElement : strutsActionElements) {
2147 String strutsActionPath = strutsActionElement.elementText(
2148 "struts-action-path");
2149
2150 if (!checkPermission(
2151 PACLConstants.PORTAL_HOOK_PERMISSION_STRUTS_ACTION_PATH,
2152 portletClassLoader, strutsActionPath,
2153 "Rejecting struts action path " + strutsActionPath)) {
2154
2155 continue;
2156 }
2157
2158 String strutsActionImpl = strutsActionElement.elementText(
2159 "struts-action-impl");
2160
2161 Object strutsAction = initStrutsAction(
2162 strutsActionImpl, portletClassLoader);
2163
2164 strutsActionContainer.registerStrutsAction(
2165 strutsActionPath, strutsAction);
2166 }
2167 }
2168
2169 protected void resetPortalProperties(
2170 String servletContextName, Properties portalProperties,
2171 boolean initPhase)
2172 throws Exception {
2173
2174 for (String key : _PROPS_VALUES_BOOLEAN) {
2175 String fieldName = StringUtil.replace(
2176 key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2177
2178 if (!containsKey(portalProperties, key)) {
2179 continue;
2180 }
2181
2182 try {
2183 Field field = PropsValues.class.getField(fieldName);
2184
2185 Boolean value = Boolean.valueOf(
2186 GetterUtil.getBoolean(PropsUtil.get(key)));
2187
2188 field.setBoolean(null, value);
2189 }
2190 catch (Exception e) {
2191 _log.error(
2192 "Error setting field " + fieldName + ": " + e.getMessage());
2193 }
2194 }
2195
2196 for (String key : _PROPS_VALUES_INTEGER) {
2197 String fieldName = StringUtil.replace(
2198 key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2199
2200 if (!containsKey(portalProperties, key)) {
2201 continue;
2202 }
2203
2204 try {
2205 Field field = PropsValues.class.getField(fieldName);
2206
2207 Integer value = Integer.valueOf(
2208 GetterUtil.getInteger(PropsUtil.get(key)));
2209
2210 field.setInt(null, value);
2211 }
2212 catch (Exception e) {
2213 _log.error(
2214 "Error setting field " + fieldName + ": " + e.getMessage());
2215 }
2216 }
2217
2218 for (String key : _PROPS_VALUES_LONG) {
2219 String fieldName = StringUtil.replace(
2220 key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2221
2222 if (!containsKey(portalProperties, key)) {
2223 continue;
2224 }
2225
2226 try {
2227 Field field = PropsValues.class.getField(fieldName);
2228
2229 Long value = Long.valueOf(
2230 GetterUtil.getLong(PropsUtil.get(key)));
2231
2232 field.setLong(null, value);
2233 }
2234 catch (Exception e) {
2235 _log.error(
2236 "Error setting field " + fieldName + ": " + e.getMessage());
2237 }
2238 }
2239
2240 for (String key : _PROPS_VALUES_STRING) {
2241 String fieldName = StringUtil.replace(
2242 key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2243
2244 if (!containsKey(portalProperties, key)) {
2245 continue;
2246 }
2247
2248 try {
2249 Field field = PropsValues.class.getField(fieldName);
2250
2251 String value = GetterUtil.getString(PropsUtil.get(key));
2252
2253 field.set(null, value);
2254 }
2255 catch (Exception e) {
2256 _log.error(
2257 "Error setting field " + fieldName + ": " + e.getMessage());
2258 }
2259 }
2260
2261 resetPortalPropertiesStringArray(
2262 servletContextName, portalProperties, initPhase,
2263 _PROPS_VALUES_MERGE_STRING_ARRAY, _mergeStringArraysContainerMap);
2264
2265 resetPortalPropertiesStringArray(
2266 servletContextName, portalProperties, initPhase,
2267 _PROPS_VALUES_OVERRIDE_STRING_ARRAY,
2268 _overrideStringArraysContainerMap);
2269
2270 if (containsKey(portalProperties, LOCALES) ||
2271 containsKey(portalProperties, LOCALES_BETA)) {
2272
2273 PropsValues.LOCALES = PropsUtil.getArray(LOCALES);
2274
2275 LanguageUtil.init();
2276 }
2277
2278 if (containsKey(
2279 portalProperties,
2280 PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST)) {
2281
2282 PortalUtil.resetPortletAddDefaultResourceCheckWhitelist();
2283 }
2284
2285 if (containsKey(
2286 portalProperties,
2287 PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST_ACTIONS)) {
2288
2289 PortalUtil.resetPortletAddDefaultResourceCheckWhitelistActions();
2290 }
2291
2292 CacheUtil.clearCache();
2293
2294 JavaScriptBundleUtil.clearCache();
2295 }
2296
2297 protected void resetPortalPropertiesStringArray(
2298 String servletContextName, Properties portalProperties,
2299 boolean initPhase, String[] propsValuesStringArray,
2300 Map<String, StringArraysContainer> stringArraysContainerMap) {
2301
2302 for (String key : propsValuesStringArray) {
2303 String fieldName = StringUtil.replace(
2304 key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2305
2306 if (!containsKey(portalProperties, key)) {
2307 continue;
2308 }
2309
2310 try {
2311 resetPortalPropertiesStringArray(
2312 servletContextName, portalProperties, initPhase,
2313 propsValuesStringArray, stringArraysContainerMap, key,
2314 fieldName);
2315 }
2316 catch (Exception e) {
2317 _log.error(
2318 "Error setting field " + fieldName + ": " + e.getMessage());
2319 }
2320 }
2321 }
2322
2323 protected void resetPortalPropertiesStringArray(
2324 String servletContextName, Properties portalProperties,
2325 boolean initPhase, String[] propsValuesStringArray,
2326 Map<String, StringArraysContainer> stringArraysContainerMap,
2327 String key, String fieldName)
2328 throws Exception {
2329
2330 Field field = PropsValues.class.getField(fieldName);
2331
2332 StringArraysContainer stringArraysContainer =
2333 stringArraysContainerMap.get(key);
2334
2335 String[] value = null;
2336
2337 if (initPhase) {
2338 if (stringArraysContainer
2339 instanceof OverrideStringArraysContainer) {
2340
2341 OverrideStringArraysContainer overrideStringArraysContainer =
2342 (OverrideStringArraysContainer)stringArraysContainer;
2343
2344 if (overrideStringArraysContainer.isOverridden()) {
2345 _log.error("Error setting overridden field " + fieldName);
2346
2347 return;
2348 }
2349
2350 value = StringUtil.split(portalProperties.getProperty(key));
2351 }
2352 else {
2353 value = PropsUtil.getArray(key);
2354 }
2355 }
2356
2357 stringArraysContainer.setPluginStringArray(servletContextName, value);
2358
2359 value = stringArraysContainer.getStringArray();
2360
2361 field.set(null, value);
2362 }
2363
2364 protected void updateRelease(
2365 String servletContextName, ClassLoader portletClassLoader,
2366 Properties unfilteredPortalProperties)
2367 throws Exception {
2368
2369 int buildNumber = GetterUtil.getInteger(
2370 unfilteredPortalProperties.getProperty(
2371 PropsKeys.RELEASE_INFO_BUILD_NUMBER));
2372
2373 if (buildNumber <= 0) {
2374 _log.error(
2375 "Skipping upgrade processes for " + servletContextName +
2376 " because \"release.info.build.number\" is not specified");
2377
2378 return;
2379 }
2380
2381 Release release = null;
2382
2383 try {
2384 release = ReleaseLocalServiceUtil.getRelease(
2385 servletContextName, buildNumber);
2386 }
2387 catch (PortalException pe) {
2388 int previousBuildNumber = GetterUtil.getInteger(
2389 unfilteredPortalProperties.getProperty(
2390 PropsKeys.RELEASE_INFO_PREVIOUS_BUILD_NUMBER),
2391 buildNumber);
2392
2393 release = ReleaseLocalServiceUtil.addRelease(
2394 servletContextName, previousBuildNumber);
2395 }
2396
2397 if (buildNumber == release.getBuildNumber()) {
2398 if (_log.isDebugEnabled()) {
2399 _log.debug(
2400 "Skipping upgrade processes for " + servletContextName +
2401 " because it is already up to date");
2402 }
2403 }
2404 else if (buildNumber < release.getBuildNumber()) {
2405 throw new UpgradeException(
2406 "Skipping upgrade processes for " + servletContextName +
2407 " because you are trying to upgrade with an older version");
2408 }
2409 else {
2410 String[] upgradeProcessClassNames = StringUtil.split(
2411 unfilteredPortalProperties.getProperty(
2412 PropsKeys.UPGRADE_PROCESSES));
2413
2414 boolean indexOnUpgrade = GetterUtil.getBoolean(
2415 unfilteredPortalProperties.getProperty(
2416 PropsKeys.INDEX_ON_UPGRADE),
2417 PropsValues.INDEX_ON_UPGRADE);
2418
2419 UpgradeProcessUtil.upgradeProcess(
2420 release.getBuildNumber(), upgradeProcessClassNames,
2421 portletClassLoader, indexOnUpgrade);
2422 }
2423
2424 ReleaseLocalServiceUtil.updateRelease(
2425 release.getReleaseId(), buildNumber, null, true);
2426 }
2427
2428 private static final String[] _PROPS_KEYS_EVENTS = {
2429 LOGIN_EVENTS_POST, LOGIN_EVENTS_PRE, LOGOUT_EVENTS_POST,
2430 LOGOUT_EVENTS_PRE, SERVLET_SERVICE_EVENTS_POST,
2431 SERVLET_SERVICE_EVENTS_PRE
2432 };
2433
2434 private static final String[] _PROPS_KEYS_SESSION_EVENTS = {
2435 SERVLET_SESSION_CREATE_EVENTS, SERVLET_SESSION_DESTROY_EVENTS
2436 };
2437
2438 private static final String[] _PROPS_VALUES_BOOLEAN = {
2439 "auth.forward.by.last.path", "captcha.check.portal.create_account",
2440 "dl.file.entry.drafts.enabled",
2441 "field.enable.com.liferay.portal.model.Contact.birthday",
2442 "field.enable.com.liferay.portal.model.Contact.male",
2443 "field.enable.com.liferay.portal.model.Organization.status",
2444 "javascript.fast.load", "layout.template.cache.enabled",
2445 "layout.user.private.layouts.auto.create",
2446 "layout.user.private.layouts.enabled",
2447 "layout.user.private.layouts.power.user.required",
2448 "layout.user.public.layouts.auto.create",
2449 "layout.user.public.layouts.enabled",
2450 "layout.user.public.layouts.power.user.required",
2451 "login.create.account.allow.custom.password",
2452 "my.sites.show.private.sites.with.no.layouts",
2453 "my.sites.show.public.sites.with.no.layouts",
2454 "my.sites.show.user.private.sites.with.no.layouts",
2455 "my.sites.show.user.public.sites.with.no.layouts",
2456 "portlet.add.default.resource.check.enabled", "session.store.password",
2457 "terms.of.use.required", "theme.css.fast.load",
2458 "theme.images.fast.load", "theme.jsp.override.enabled",
2459 "theme.loader.new.theme.id.on.import", "theme.portlet.decorate.default",
2460 "theme.portlet.sharing.default",
2461 "user.notification.event.confirmation.enabled",
2462 "users.email.address.required", "users.screen.name.always.autogenerate"
2463 };
2464
2465 private static final String[] _PROPS_VALUES_INTEGER = {
2466 "session.max.allowed", "users.image.max.height",
2467 "users.image.max.width",
2468 };
2469
2470 private static final String[] _PROPS_VALUES_LONG = {
2471 };
2472
2473 private static final String[] _PROPS_VALUES_MERGE_STRING_ARRAY = {
2474 "admin.default.group.names", "admin.default.role.names",
2475 "admin.default.user.group.names", "asset.publisher.display.styles",
2476 "company.settings.form.configuration",
2477 "company.settings.form.identification",
2478 "company.settings.form.miscellaneous", "convert.processes",
2479 "dockbar.add.portlets", "journal.article.form.add",
2480 "journal.article.form.translate", "journal.article.form.update",
2481 "layout.form.add", "layout.form.update", "layout.set.form.update",
2482 "layout.static.portlets.all", "layout.types",
2483 "organizations.form.add.identification", "organizations.form.add.main",
2484 "organizations.form.add.miscellaneous",
2485 "portlet.add.default.resource.check.whitelist",
2486 "portlet.add.default.resource.check.whitelist.actions",
2487 "session.phishing.protected.attributes", "sites.form.add.advanced",
2488 "sites.form.add.main", "sites.form.add.seo",
2489 "sites.form.update.advanced", "sites.form.update.main",
2490 "sites.form.update.seo", "users.form.add.identification",
2491 "users.form.add.main", "users.form.add.miscellaneous",
2492 "users.form.my.account.identification", "users.form.my.account.main",
2493 "users.form.my.account.miscellaneous",
2494 "users.form.update.identification", "users.form.update.main",
2495 "users.form.update.miscellaneous"
2496 };
2497
2498 private static final String[] _PROPS_VALUES_OBSOLETE = {
2499 "layout.user.private.layouts.modifiable",
2500 "layout.user.public.layouts.modifiable"
2501 };
2502
2503 private static final String[] _PROPS_VALUES_OVERRIDE_STRING_ARRAY = {
2504 "locales.beta"
2505 };
2506
2507 private static final String[] _PROPS_VALUES_STRING = {
2508 "company.default.locale", "company.default.time.zone",
2509 "default.landing.page.path",
2510 "passwords.passwordpolicytoolkit.generator",
2511 "passwords.passwordpolicytoolkit.static",
2512 "phone.number.format.international.regexp",
2513 "phone.number.format.usa.regexp", "theme.shortcut.icon"
2514 };
2515
2516 private static Log _log = LogFactoryUtil.getLog(
2517 HookHotDeployListener.class);
2518
2519 private Map<String, AuthenticatorsContainer> _authenticatorsContainerMap =
2520 new HashMap<String, AuthenticatorsContainer>();
2521 private Map<String, AuthFailuresContainer> _authFailuresContainerMap =
2522 new HashMap<String, AuthFailuresContainer>();
2523 private Map<String, AuthPublicPathsContainer> _authPublicPathsContainerMap =
2524 new HashMap<String, AuthPublicPathsContainer>();
2525 private Map<String, AutoDeployListenersContainer>
2526 _autoDeployListenersContainerMap =
2527 new HashMap<String, AutoDeployListenersContainer>();
2528 private Map<String, AutoLoginsContainer> _autoLoginsContainerMap =
2529 new HashMap<String, AutoLoginsContainer>();
2530 private Map<String, CustomJspBag> _customJspBagsMap =
2531 new HashMap<String, CustomJspBag>();
2532 private Map<String, DLFileEntryProcessorContainer>
2533 _dlFileEntryProcessorContainerMap =
2534 new HashMap<String, DLFileEntryProcessorContainer>();
2535 private Map<String, DLRepositoryContainer> _dlRepositoryContainerMap =
2536 new HashMap<String, DLRepositoryContainer>();
2537 private Map<String, EventsContainer> _eventsContainerMap =
2538 new HashMap<String, EventsContainer>();
2539 private Map<String, HotDeployListenersContainer>
2540 _hotDeployListenersContainerMap =
2541 new HashMap<String, HotDeployListenersContainer>();
2542 private Map<String, IndexerPostProcessorContainer>
2543 _indexerPostProcessorContainerMap =
2544 new HashMap<String, IndexerPostProcessorContainer>();
2545 private Map<String, LanguagesContainer> _languagesContainerMap =
2546 new HashMap<String, LanguagesContainer>();
2547 private Map<String, LockListenerContainer> _lockListenerContainerMap =
2548 new HashMap<String, LockListenerContainer>();
2549 private Map<String, StringArraysContainer> _mergeStringArraysContainerMap =
2550 new HashMap<String, StringArraysContainer>();
2551 private Map<String, ModelListenersContainer> _modelListenersContainerMap =
2552 new HashMap<String, ModelListenersContainer>();
2553 private Map<String, StringArraysContainer>
2554 _overrideStringArraysContainerMap =
2555 new HashMap<String, StringArraysContainer>();
2556 private Map<String, Properties> _portalPropertiesMap =
2557 new HashMap<String, Properties>();
2558 private Set<String> _propsKeysEvents = SetUtil.fromArray(
2559 _PROPS_KEYS_EVENTS);
2560 private Set<String> _propsKeysSessionEvents = SetUtil.fromArray(
2561 _PROPS_KEYS_SESSION_EVENTS);
2562 private Map<String, SanitizerContainer> _sanitizerContainerMap =
2563 new HashMap<String, SanitizerContainer>();
2564 private ServicesContainer _servicesContainer = new ServicesContainer();
2565 private Set<String> _servletContextNames = new HashSet<String>();
2566 private Map<String, ServletFiltersContainer> _servletFiltersContainerMap =
2567 new HashMap<String, ServletFiltersContainer>();
2568 private Map<String, StrutsActionsContainer> _strutsActionsContainerMap =
2569 new HashMap<String, StrutsActionsContainer>();
2570
2571 private class AuthenticatorsContainer {
2572
2573 public void registerAuthenticator(
2574 String key, Authenticator authenticator) {
2575
2576 List<Authenticator> authenticators = _authenticators.get(key);
2577
2578 if (authenticators == null) {
2579 authenticators = new ArrayList<Authenticator>();
2580
2581 _authenticators.put(key, authenticators);
2582 }
2583
2584 AuthPipeline.registerAuthenticator(key, authenticator);
2585
2586 authenticators.add(authenticator);
2587 }
2588
2589 public void unregisterAuthenticators() {
2590 for (Map.Entry<String, List<Authenticator>> entry :
2591 _authenticators.entrySet()) {
2592
2593 String key = entry.getKey();
2594 List<Authenticator> authenticators = entry.getValue();
2595
2596 for (Authenticator authenticator : authenticators) {
2597 AuthPipeline.unregisterAuthenticator(key, authenticator);
2598 }
2599 }
2600 }
2601
2602 private Map<String, List<Authenticator>> _authenticators =
2603 new HashMap<String, List<Authenticator>>();
2604
2605 }
2606
2607 private class AuthFailuresContainer {
2608
2609 public void registerAuthFailure(String key, AuthFailure authFailure) {
2610 List<AuthFailure> authFailures = _authFailures.get(key);
2611
2612 if (authFailures == null) {
2613 authFailures = new ArrayList<AuthFailure>();
2614
2615 _authFailures.put(key, authFailures);
2616 }
2617
2618 AuthPipeline.registerAuthFailure(key, authFailure);
2619
2620 authFailures.add(authFailure);
2621 }
2622
2623 public void unregisterAuthFailures() {
2624 for (Map.Entry<String, List<AuthFailure>> entry :
2625 _authFailures.entrySet()) {
2626
2627 String key = entry.getKey();
2628 List<AuthFailure> authFailures = entry.getValue();
2629
2630 for (AuthFailure authFailure : authFailures) {
2631 AuthPipeline.unregisterAuthFailure(key, authFailure);
2632 }
2633 }
2634 }
2635
2636 private Map<String, List<AuthFailure>> _authFailures =
2637 new HashMap<String, List<AuthFailure>>();
2638
2639 }
2640
2641 private class AuthPublicPathsContainer {
2642
2643 public void registerPaths(String[] paths) {
2644 for (String path : paths) {
2645 _paths.add(path);
2646 }
2647
2648 AuthPublicPathRegistry.register(paths);
2649 }
2650
2651 public void unregisterPaths() {
2652 for (String path : _paths) {
2653 AuthPublicPathRegistry.unregister(path);
2654 }
2655
2656 _paths.clear();
2657 }
2658
2659 private Set<String> _paths = new HashSet<String>();
2660
2661 }
2662
2663 private class AutoDeployListenersContainer {
2664
2665 public void registerAutoDeployListener(
2666 AutoDeployListener autoDeployListener) {
2667
2668 AutoDeployDir autoDeployDir = AutoDeployUtil.getDir(
2669 AutoDeployDir.DEFAULT_NAME);
2670
2671 if (autoDeployDir == null) {
2672 return;
2673 }
2674
2675 autoDeployDir.registerListener(autoDeployListener);
2676
2677 _autoDeployListeners.add(autoDeployListener);
2678 }
2679
2680 public void unregisterAutoDeployListeners() {
2681 AutoDeployDir autoDeployDir = AutoDeployUtil.getDir(
2682 AutoDeployDir.DEFAULT_NAME);
2683
2684 if (autoDeployDir == null) {
2685 return;
2686 }
2687
2688 for (AutoDeployListener autoDeployListener : _autoDeployListeners) {
2689 autoDeployDir.unregisterListener(autoDeployListener);
2690 }
2691 }
2692
2693 private List<AutoDeployListener> _autoDeployListeners =
2694 new ArrayList<AutoDeployListener>();
2695
2696 }
2697
2698 private class AutoLoginsContainer {
2699
2700 public void registerAutoLogin(AutoLogin autoLogin) {
2701 AutoLoginFilter.registerAutoLogin(autoLogin);
2702
2703 _autoLogins.add(autoLogin);
2704 }
2705
2706 public void unregisterAutoLogins() {
2707 for (AutoLogin autoLogin : _autoLogins) {
2708 AutoLoginFilter.unregisterAutoLogin(autoLogin);
2709 }
2710 }
2711
2712 private List<AutoLogin> _autoLogins = new ArrayList<AutoLogin>();
2713
2714 }
2715
2716 private class CustomJspBag {
2717
2718 public CustomJspBag(
2719 String customJspDir, boolean customJspGlobal,
2720 List<String> customJsps) {
2721
2722 _customJspDir = customJspDir;
2723 _customJspGlobal = customJspGlobal;
2724 _customJsps = customJsps;
2725 }
2726
2727 public String getCustomJspDir() {
2728 return _customJspDir;
2729 }
2730
2731 public List<String> getCustomJsps() {
2732 return _customJsps;
2733 }
2734
2735 public boolean isCustomJspGlobal() {
2736 return _customJspGlobal;
2737 }
2738
2739 private String _customJspDir;
2740 private boolean _customJspGlobal;
2741 private List<String> _customJsps;
2742
2743 }
2744
2745 private class DLFileEntryProcessorContainer {
2746
2747 public void registerDLProcessor(DLProcessor dlProcessor) {
2748 DLProcessorRegistryUtil.register(dlProcessor);
2749
2750 _dlProcessors.add(dlProcessor);
2751 }
2752
2753 public void unregisterDLProcessors() {
2754 for (DLProcessor dlProcessor : _dlProcessors) {
2755 DLProcessorRegistryUtil.unregister(dlProcessor);
2756 }
2757
2758 _dlProcessors.clear();
2759 }
2760
2761 private List<DLProcessor> _dlProcessors = new ArrayList<DLProcessor>();
2762
2763 }
2764
2765 private class DLRepositoryContainer {
2766
2767 public void registerRepositoryFactory(
2768 String className, RepositoryFactory repositoryFactory) {
2769
2770 RepositoryFactoryUtil.registerRepositoryFactory(
2771 className, repositoryFactory);
2772
2773 _classNames.add(className);
2774 }
2775
2776 public void unregisterRepositoryFactories() {
2777 for (String className : _classNames) {
2778 RepositoryFactoryUtil.unregisterRepositoryFactory(className);
2779 }
2780
2781 _classNames.clear();
2782 }
2783
2784 private List<String> _classNames = new ArrayList<String>();
2785
2786 }
2787
2788 private class EventsContainer {
2789
2790 public void registerEvent(String eventName, Object event) {
2791 List<Object> events = _eventsMap.get(eventName);
2792
2793 if (events == null) {
2794 events = new ArrayList<Object>();
2795
2796 _eventsMap.put(eventName, events);
2797 }
2798
2799 events.add(event);
2800 }
2801
2802 public void unregisterEvents() {
2803 for (Map.Entry<String, List<Object>> entry :
2804 _eventsMap.entrySet()) {
2805
2806 String eventName = entry.getKey();
2807 List<Object> events = entry.getValue();
2808
2809 for (Object event : events) {
2810 EventsProcessorUtil.unregisterEvent(eventName, event);
2811 }
2812 }
2813 }
2814
2815 private Map<String, List<Object>> _eventsMap =
2816 new HashMap<String, List<Object>>();
2817
2818 }
2819
2820 private class HotDeployListenersContainer {
2821
2822 public void registerHotDeployListener(
2823 HotDeployListener hotDeployListener) {
2824
2825 HotDeployUtil.registerListener(hotDeployListener);
2826
2827 _hotDeployListeners.add(hotDeployListener);
2828 }
2829
2830 public void unregisterHotDeployListeners() {
2831 for (HotDeployListener hotDeployListener : _hotDeployListeners) {
2832 HotDeployUtil.unregisterListener(hotDeployListener);
2833 }
2834 }
2835
2836 private List<HotDeployListener> _hotDeployListeners =
2837 new ArrayList<HotDeployListener>();
2838
2839 }
2840
2841 private class IndexerPostProcessorContainer {
2842
2843 public void registerIndexerPostProcessor(
2844 String indexerClassName,
2845 IndexerPostProcessor indexerPostProcessor) {
2846
2847 List<IndexerPostProcessor> indexerPostProcessors =
2848 _indexerPostProcessors.get(indexerClassName);
2849
2850 if (indexerPostProcessors == null) {
2851 indexerPostProcessors = new ArrayList<IndexerPostProcessor>();
2852
2853 _indexerPostProcessors.put(
2854 indexerClassName, indexerPostProcessors);
2855 }
2856
2857 indexerPostProcessors.add(indexerPostProcessor);
2858 }
2859
2860 public void unregisterIndexerPostProcessor() {
2861 for (Map.Entry<String, List<IndexerPostProcessor>> entry :
2862 _indexerPostProcessors.entrySet()) {
2863
2864 String indexerClassName = entry.getKey();
2865 List<IndexerPostProcessor> indexerPostProcessors =
2866 entry.getValue();
2867
2868 Indexer indexer = IndexerRegistryUtil.getIndexer(
2869 indexerClassName);
2870
2871 for (IndexerPostProcessor indexerPostProcessor :
2872 indexerPostProcessors) {
2873
2874 indexer.unregisterIndexerPostProcessor(
2875 indexerPostProcessor);
2876 }
2877 }
2878 }
2879
2880 private Map<String, List<IndexerPostProcessor>> _indexerPostProcessors =
2881 new HashMap<String, List<IndexerPostProcessor>>();
2882
2883 }
2884
2885 private class LanguagesContainer {
2886
2887 public void addLanguage(
2888 Locale locale, Map<String, String> languageMap) {
2889
2890 Map<String, String> oldLanguageMap =
2891 LanguageResources.putLanguageMap(locale, languageMap);
2892
2893 _languagesMap.put(locale, oldLanguageMap);
2894 }
2895
2896 public void unregisterLanguages() {
2897 for (Map.Entry<Locale, Map<String, String>> entry :
2898 _languagesMap.entrySet()) {
2899
2900 Locale locale = entry.getKey();
2901 Map<String, String> languageMap = entry.getValue();
2902
2903 LanguageResources.putLanguageMap(locale, languageMap);
2904 }
2905 }
2906
2907 private Map<Locale, Map<String, String>> _languagesMap =
2908 new HashMap<Locale, Map<String, String>>();
2909
2910 }
2911
2912 private class LockListenerContainer {
2913
2914 public void registerLockListener(LockListener lockListener) {
2915 LockListenerRegistryUtil.register(lockListener);
2916
2917 _lockListeners.add(lockListener);
2918 }
2919
2920 public void unregisterLockListeners() {
2921 for (LockListener lockListener : _lockListeners) {
2922 LockListenerRegistryUtil.unregister(lockListener);
2923 }
2924
2925 _lockListeners.clear();
2926 }
2927
2928 private List<LockListener> _lockListeners =
2929 new ArrayList<LockListener>();
2930
2931 }
2932
2933 private class MergeStringArraysContainer implements StringArraysContainer {
2934
2935 private MergeStringArraysContainer(String key) {
2936 _portalStringArray = PropsUtil.getArray(key);
2937 }
2938
2939 @Override
2940 public String[] getStringArray() {
2941 List<String> mergedStringList = new UniqueList<String>();
2942
2943 mergedStringList.addAll(ListUtil.fromArray(_portalStringArray));
2944
2945 for (Map.Entry<String, String[]> entry :
2946 _pluginStringArrayMap.entrySet()) {
2947
2948 String[] pluginStringArray = entry.getValue();
2949
2950 mergedStringList.addAll(ListUtil.fromArray(pluginStringArray));
2951 }
2952
2953 return mergedStringList.toArray(
2954 new String[mergedStringList.size()]);
2955 }
2956
2957 @Override
2958 public void setPluginStringArray(
2959 String servletContextName, String[] pluginStringArray) {
2960
2961 if (pluginStringArray != null) {
2962 _pluginStringArrayMap.put(
2963 servletContextName, pluginStringArray);
2964 }
2965 else {
2966 _pluginStringArrayMap.remove(servletContextName);
2967 }
2968 }
2969
2970 private String[] _portalStringArray;
2971 private Map<String, String[]> _pluginStringArrayMap =
2972 new HashMap<String, String[]>();
2973
2974 }
2975
2976 private class ModelListenersContainer {
2977
2978 public void registerModelListener(
2979 String modelName, ModelListener<BaseModel<?>> modelListener) {
2980
2981 List<ModelListener<BaseModel<?>>> modelListeners =
2982 _modelListenersMap.get(modelName);
2983
2984 if (modelListeners == null) {
2985 modelListeners = new ArrayList<ModelListener<BaseModel<?>>>();
2986
2987 _modelListenersMap.put(modelName, modelListeners);
2988 }
2989
2990 modelListeners.add(modelListener);
2991 }
2992
2993 @SuppressWarnings("rawtypes")
2994 public void unregisterModelListeners() {
2995 for (Map.Entry<String, List<ModelListener<BaseModel<?>>>> entry :
2996 _modelListenersMap.entrySet()) {
2997
2998 String modelName = entry.getKey();
2999 List<ModelListener<BaseModel<?>>> modelListeners =
3000 entry.getValue();
3001
3002 BasePersistence persistence = getPersistence(modelName);
3003
3004 for (ModelListener<BaseModel<?>> modelListener :
3005 modelListeners) {
3006
3007 persistence.unregisterListener(modelListener);
3008 }
3009 }
3010 }
3011
3012 private Map<String, List<ModelListener<BaseModel<?>>>>
3013 _modelListenersMap =
3014 new HashMap<String, List<ModelListener<BaseModel<?>>>>();
3015
3016 }
3017
3018 private class OverrideStringArraysContainer
3019 implements StringArraysContainer {
3020
3021 private OverrideStringArraysContainer(String key) {
3022 _portalStringArray = PropsUtil.getArray(key);
3023 }
3024
3025 @Override
3026 public String[] getStringArray() {
3027 if (_pluginStringArray != null) {
3028 return _pluginStringArray;
3029 }
3030
3031 return _portalStringArray;
3032 }
3033
3034 public boolean isOverridden() {
3035 if (Validator.isNotNull(_servletContextName)) {
3036 return true;
3037 }
3038 else {
3039 return false;
3040 }
3041 }
3042
3043 @Override
3044 public void setPluginStringArray(
3045 String servletContextName, String[] pluginStringArray) {
3046
3047 if (pluginStringArray != null) {
3048 if (!isOverridden()) {
3049 _servletContextName = servletContextName;
3050 _pluginStringArray = pluginStringArray;
3051 }
3052 }
3053 else {
3054 if (_servletContextName.equals(servletContextName)) {
3055 _servletContextName = null;
3056 _pluginStringArray = null;
3057 }
3058 }
3059 }
3060
3061 private String[] _pluginStringArray;
3062 private String[] _portalStringArray;
3063 private String _servletContextName;
3064
3065 }
3066
3067 private class SanitizerContainer {
3068
3069 public void registerSanitizer(Sanitizer sanitizer) {
3070 _sanitizers.add(sanitizer);
3071
3072 SanitizerImpl sanitizerImpl =
3073 (SanitizerImpl)SanitizerUtil.getSanitizer();
3074
3075 sanitizerImpl.registerSanitizer(sanitizer);
3076 }
3077
3078 public void unregisterSanitizers() {
3079 SanitizerImpl sanitizerImpl =
3080 (SanitizerImpl)SanitizerUtil.getSanitizer();
3081
3082 for (Sanitizer sanitizer : _sanitizers) {
3083 sanitizerImpl.unregisterSanitizer(sanitizer);
3084 }
3085 }
3086
3087 private List<Sanitizer> _sanitizers = new ArrayList<Sanitizer>();
3088
3089 }
3090
3091 private class ServiceBag {
3092
3093 public ServiceBag(Object originalService) {
3094 _originalService = originalService;
3095 }
3096
3097 public void addCustomServiceConstructor(
3098 String servletContextName, ClassLoader portletClassLoader,
3099 Class<?> serviceTypeClass, Constructor<?> serviceImplConstructor) {
3100
3101 List<ServiceConstructor> serviceConstructors =
3102 _serviceConstructors.get(servletContextName);
3103
3104 if (serviceConstructors == null) {
3105 serviceConstructors = new ArrayList<ServiceConstructor>();
3106
3107 _serviceConstructors.put(
3108 servletContextName, serviceConstructors);
3109 }
3110
3111 ServiceConstructor serviceConstructor = new ServiceConstructor(
3112 portletClassLoader, serviceTypeClass, serviceImplConstructor);
3113
3114 serviceConstructors.add(serviceConstructor);
3115 }
3116
3117 public Object getCustomService() throws Exception {
3118 List<ServiceConstructor> serviceConstructors =
3119 new ArrayList<ServiceConstructor>();
3120
3121 for (Map.Entry<String, List<ServiceConstructor>> entry :
3122 _serviceConstructors.entrySet()) {
3123
3124 serviceConstructors.addAll(entry.getValue());
3125 }
3126
3127 Object customService = _originalService;
3128
3129 for (ServiceConstructor serviceConstructor : serviceConstructors) {
3130 ClassLoader portletClassLoader =
3131 serviceConstructor._portletClassLoader;
3132 Class<?> serviceTypeClass =
3133 serviceConstructor._serviceTypeClass;
3134 Constructor<?> serviceImplConstructor =
3135 serviceConstructor._serviceImplConstructor;
3136
3137 customService = serviceImplConstructor.newInstance(
3138 customService);
3139
3140 customService = ProxyUtil.newProxyInstance(
3141 portletClassLoader, new Class<?>[] {serviceTypeClass},
3142 new ClassLoaderBeanHandler(
3143 customService, portletClassLoader));
3144 }
3145
3146 return customService;
3147 }
3148
3149 private Object _originalService;
3150 private Map<String, List<ServiceConstructor>> _serviceConstructors =
3151 new HashMap<String, List<ServiceConstructor>>();
3152
3153 }
3154
3155 private class ServiceConstructor {
3156
3157 public ServiceConstructor(
3158 ClassLoader portletClassLoader, Class<?> serviceTypeClass,
3159 Constructor<?> serviceImplConstructor) {
3160
3161 _portletClassLoader = portletClassLoader;
3162 _serviceTypeClass = serviceTypeClass;
3163 _serviceImplConstructor = serviceImplConstructor;
3164 }
3165
3166 private ClassLoader _portletClassLoader;
3167 private Constructor<?> _serviceImplConstructor;
3168 private Class<?> _serviceTypeClass;
3169
3170 }
3171
3172 private class ServicesContainer {
3173
3174 public void addServiceBag(
3175 String servletContextName, ClassLoader portletClassLoader,
3176 String serviceType, Class<?> serviceTypeClass,
3177 Constructor<?> serviceImplConstructor, Object wrappedService) {
3178
3179 ServiceBag serviceBag = _serviceBags.get(serviceType);
3180
3181 if (serviceBag == null) {
3182 serviceBag = new ServiceBag(wrappedService);
3183
3184 _serviceBags.put(serviceType, serviceBag);
3185 }
3186
3187 serviceBag.addCustomServiceConstructor(
3188 servletContextName, portletClassLoader, serviceTypeClass,
3189 serviceImplConstructor);
3190 }
3191
3192 private Map<String, ServiceBag> _serviceBags =
3193 new HashMap<String, ServiceBag>();
3194
3195 }
3196
3197 private class ServletFiltersContainer {
3198
3199 public InvokerFilterHelper getInvokerFilterHelper() {
3200 ServletContext portalServletContext = ServletContextPool.get(
3201 PortalUtil.getPathContext());
3202
3203 InvokerFilterHelper invokerFilterHelper =
3204 (InvokerFilterHelper)portalServletContext.getAttribute(
3205 InvokerFilterHelper.class.getName());
3206
3207 return invokerFilterHelper;
3208 }
3209
3210 public void registerFilter(
3211 String filterName, Filter filter, FilterConfig filterConfig) {
3212
3213 InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3214
3215 Filter previousFilter = invokerFilterHelper.registerFilter(
3216 filterName, filter);
3217
3218 _filterConfigs.put(filterName, filterConfig);
3219 _filters.put(filterName, previousFilter);
3220 }
3221
3222 public void registerFilterMapping(
3223 String filterName, List<String> urlPatterns,
3224 List<String> dispatchers, String positionFilterName,
3225 boolean after) {
3226
3227 InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3228
3229 Filter filter = invokerFilterHelper.getFilter(filterName);
3230
3231 FilterConfig filterConfig = _filterConfigs.get(filterName);
3232
3233 if (filterConfig == null) {
3234 filterConfig = invokerFilterHelper.getFilterConfig(filterName);
3235 }
3236
3237 if (filter == null) {
3238 if (_log.isWarnEnabled()) {
3239 _log.warn(
3240 "No filter exists with filter mapping " + filterName);
3241 }
3242
3243 return;
3244 }
3245
3246 FilterMapping filterMapping = new FilterMapping(
3247 filter, filterConfig, urlPatterns, dispatchers);
3248
3249 invokerFilterHelper.registerFilterMapping(
3250 filterMapping, positionFilterName, after);
3251 }
3252
3253 public void unregisterFilterMappings() {
3254 InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3255
3256 for (String filterName : _filters.keySet()) {
3257 Filter filter = _filters.get(filterName);
3258
3259 Filter previousFilter = invokerFilterHelper.registerFilter(
3260 filterName, filter);
3261
3262 previousFilter.destroy();
3263 }
3264
3265 for (FilterMapping filterMapping : _filterMappings) {
3266 invokerFilterHelper.unregisterFilterMapping(filterMapping);
3267
3268 filterMapping.setFilter(null);
3269 }
3270 }
3271
3272 private Map<String, FilterConfig> _filterConfigs =
3273 new HashMap<String, FilterConfig>();
3274 private List<FilterMapping> _filterMappings =
3275 new ArrayList<FilterMapping>();
3276 private Map<String, Filter> _filters = new HashMap<String, Filter>();
3277
3278 }
3279
3280 private interface StringArraysContainer {
3281
3282 public String[] getStringArray();
3283
3284 public void setPluginStringArray(
3285 String servletContextName, String[] pluginStringArray);
3286
3287 }
3288
3289 private class StrutsActionsContainer {
3290
3291 public void registerStrutsAction(String path, Object strutsAction) {
3292 if (strutsAction instanceof StrutsAction) {
3293 StrutsActionRegistryUtil.register(
3294 path, (StrutsAction)strutsAction);
3295 }
3296 else {
3297 StrutsActionRegistryUtil.register(
3298 path, (StrutsPortletAction)strutsAction);
3299 }
3300
3301 _paths.add(path);
3302 }
3303
3304 public void unregisterStrutsActions() {
3305 for (String path : _paths) {
3306 StrutsActionRegistryUtil.unregister(path);
3307 }
3308
3309 _paths.clear();
3310 }
3311
3312 private List<String> _paths = new ArrayList<String>();
3313
3314 }
3315
3316 }