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