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