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