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