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