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