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