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