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