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
953 return locale;
954 }
955
956 protected BasePersistence<?> getPersistence(String modelName) {
957 int pos = modelName.lastIndexOf(CharPool.PERIOD);
958
959 String entityName = modelName.substring(pos + 1);
960
961 pos = modelName.lastIndexOf(".model.");
962
963 String packagePath = modelName.substring(0, pos);
964
965 return (BasePersistence<?>)PortalBeanLocatorUtil.locate(
966 packagePath + ".service.persistence." + entityName + "Persistence");
967 }
968
969 protected File getPortalJspBackupFile(File portalJspFile) {
970 String fileName = portalJspFile.getName();
971 String filePath = portalJspFile.toString();
972
973 int fileNameIndex = fileName.lastIndexOf(CharPool.PERIOD);
974
975 if (fileNameIndex > 0) {
976 int filePathIndex = filePath.lastIndexOf(fileName);
977
978 fileName =
979 fileName.substring(0, fileNameIndex) + ".portal" +
980 fileName.substring(fileNameIndex);
981
982 filePath = filePath.substring(0, filePathIndex) + fileName;
983 }
984 else {
985 filePath += ".portal";
986 }
987
988 return new File(filePath);
989 }
990
991 protected void initAuthenticators(
992 ClassLoader portletClassLoader, Properties portalProperties,
993 String key, AuthenticatorsContainer authenticatorsContainer)
994 throws Exception {
995
996 String[] authenticatorClassNames = StringUtil.split(
997 portalProperties.getProperty(key));
998
999 for (String authenticatorClassName : authenticatorClassNames) {
1000 Authenticator authenticator = (Authenticator)newInstance(
1001 portletClassLoader, Authenticator.class,
1002 authenticatorClassName);
1003
1004 authenticatorsContainer.registerAuthenticator(key, authenticator);
1005 }
1006 }
1007
1008 protected void initAuthenticators(
1009 String servletContextName, ClassLoader portletClassLoader,
1010 Properties portalProperties)
1011 throws Exception {
1012
1013 AuthenticatorsContainer authenticatorsContainer =
1014 new AuthenticatorsContainer();
1015
1016 _authenticatorsContainerMap.put(
1017 servletContextName, authenticatorsContainer);
1018
1019 initAuthenticators(
1020 portletClassLoader, portalProperties, AUTH_PIPELINE_PRE,
1021 authenticatorsContainer);
1022 initAuthenticators(
1023 portletClassLoader, portalProperties, AUTH_PIPELINE_POST,
1024 authenticatorsContainer);
1025 }
1026
1027 protected void initAuthFailures(
1028 ClassLoader portletClassLoader, Properties portalProperties,
1029 String key, AuthFailuresContainer authFailuresContainer)
1030 throws Exception {
1031
1032 String[] authFailureClassNames = StringUtil.split(
1033 portalProperties.getProperty(key));
1034
1035 for (String authFailureClassName : authFailureClassNames) {
1036 AuthFailure authFailure = (AuthFailure)newInstance(
1037 portletClassLoader, AuthFailure.class, authFailureClassName);
1038
1039 authFailuresContainer.registerAuthFailure(key, authFailure);
1040 }
1041 }
1042
1043 protected void initAuthFailures(
1044 String servletContextName, ClassLoader portletClassLoader,
1045 Properties portalProperties)
1046 throws Exception {
1047
1048 AuthFailuresContainer authFailuresContainer =
1049 new AuthFailuresContainer();
1050
1051 _authFailuresContainerMap.put(
1052 servletContextName, authFailuresContainer);
1053
1054 initAuthFailures(
1055 portletClassLoader, portalProperties, AUTH_FAILURE,
1056 authFailuresContainer);
1057 initAuthFailures(
1058 portletClassLoader, portalProperties, AUTH_MAX_FAILURES,
1059 authFailuresContainer);
1060 }
1061
1062 protected void initAuthPublicPaths(
1063 String servletContextName, Properties portalProperties)
1064 throws Exception {
1065
1066 AuthPublicPathsContainer authPublicPathsContainer =
1067 new AuthPublicPathsContainer();
1068
1069 _authPublicPathsContainerMap.put(
1070 servletContextName, authPublicPathsContainer);
1071
1072 String[] publicPaths = StringUtil.split(
1073 portalProperties.getProperty(AUTH_PUBLIC_PATHS));
1074
1075 authPublicPathsContainer.registerPaths(publicPaths);
1076 }
1077
1078 protected void initAuthVerifiers(
1079 String servletContextName, ClassLoader portletClassLoader,
1080 Properties portalProperties)
1081 throws Exception {
1082
1083 AuthVerifierConfigurationContainer authVerifierConfigurationContainer =
1084 new AuthVerifierConfigurationContainer();
1085
1086 _authVerifierConfigurationContainerMap.put(
1087 servletContextName, authVerifierConfigurationContainer);
1088
1089 String[] authVerifierClassNames = StringUtil.split(
1090 portalProperties.getProperty(AUTH_VERIFIER_PIPELINE));
1091
1092 for (String authVerifierClassName : authVerifierClassNames) {
1093 AuthVerifierConfiguration authVerifierConfiguration =
1094 new AuthVerifierConfiguration();
1095
1096 AuthVerifier authVerifier = (AuthVerifier)newInstance(
1097 portletClassLoader, AuthVerifier.class, authVerifierClassName);
1098
1099 authVerifierConfiguration.setAuthVerifier(authVerifier);
1100
1101 authVerifierConfiguration.setAuthVerifierClassName(
1102 authVerifierClassName);
1103
1104 Properties properties = PropertiesUtil.getProperties(
1105 portalProperties,
1106 AuthVerifierPipeline.getAuthVerifierPropertyName(
1107 authVerifierClassName),
1108 true);
1109
1110 authVerifierConfiguration.setProperties(properties);
1111
1112 authVerifierConfigurationContainer.
1113 registerAuthVerifierConfiguration(authVerifierConfiguration);
1114 }
1115 }
1116
1117 protected void initAutoDeployListeners(
1118 String servletContextName, ClassLoader portletClassLoader,
1119 Properties portalProperties)
1120 throws Exception {
1121
1122 String[] autoDeployListenerClassNames = StringUtil.split(
1123 portalProperties.getProperty(PropsKeys.AUTO_DEPLOY_LISTENERS));
1124
1125 if (autoDeployListenerClassNames.length == 0) {
1126 return;
1127 }
1128
1129 AutoDeployListenersContainer autoDeployListenersContainer =
1130 new AutoDeployListenersContainer();
1131
1132 _autoDeployListenersContainerMap.put(
1133 servletContextName, autoDeployListenersContainer);
1134
1135 for (String autoDeployListenerClassName :
1136 autoDeployListenerClassNames) {
1137
1138 AutoDeployListener autoDeployListener =
1139 (AutoDeployListener)newInstance(
1140 portletClassLoader, AutoDeployListener.class,
1141 autoDeployListenerClassName);
1142
1143 autoDeployListenersContainer.registerAutoDeployListener(
1144 autoDeployListener);
1145 }
1146 }
1147
1148 protected void initAutoLogins(
1149 String servletContextName, ClassLoader portletClassLoader,
1150 Properties portalProperties)
1151 throws Exception {
1152
1153 AutoLoginsContainer autoLoginsContainer = new AutoLoginsContainer();
1154
1155 _autoLoginsContainerMap.put(servletContextName, autoLoginsContainer);
1156
1157 String[] autoLoginClassNames = StringUtil.split(
1158 portalProperties.getProperty(AUTO_LOGIN_HOOKS));
1159
1160 for (String autoLoginClassName : autoLoginClassNames) {
1161 AutoLogin autoLogin = (AutoLogin)newInstance(
1162 portletClassLoader, AutoLogin.class, autoLoginClassName);
1163
1164 autoLoginsContainer.registerAutoLogin(autoLogin);
1165 }
1166 }
1167
1168 protected void initCustomJspBag(
1169 String servletContextName, String displayName,
1170 CustomJspBag customJspBag)
1171 throws Exception {
1172
1173 String customJspDir = customJspBag.getCustomJspDir();
1174 boolean customJspGlobal = customJspBag.isCustomJspGlobal();
1175 List<String> customJsps = customJspBag.getCustomJsps();
1176
1177 String portalWebDir = PortalUtil.getPortalWebDir();
1178
1179 for (String customJsp : customJsps) {
1180 int pos = customJsp.indexOf(customJspDir);
1181
1182 String portalJsp = customJsp.substring(pos + customJspDir.length());
1183
1184 if (customJspGlobal) {
1185 File portalJspFile = new File(portalWebDir + portalJsp);
1186 File portalJspBackupFile = getPortalJspBackupFile(
1187 portalJspFile);
1188
1189 if (portalJspFile.exists() && !portalJspBackupFile.exists()) {
1190 FileUtil.copyFile(portalJspFile, portalJspBackupFile);
1191 }
1192 }
1193 else {
1194 portalJsp = CustomJspRegistryUtil.getCustomJspFileName(
1195 servletContextName, portalJsp);
1196 }
1197
1198 FileUtil.copyFile(customJsp, portalWebDir + portalJsp);
1199 }
1200
1201 if (!customJspGlobal) {
1202 CustomJspRegistryUtil.registerServletContextName(
1203 servletContextName, displayName);
1204 }
1205 }
1206
1207 protected void initCustomJspDir(
1208 ServletContext servletContext, String servletContextName,
1209 ClassLoader portletClassLoader, PluginPackage pluginPackage,
1210 Element rootElement)
1211 throws Exception {
1212
1213 String customJspDir = rootElement.elementText("custom-jsp-dir");
1214
1215 if (Validator.isNull(customJspDir)) {
1216 return;
1217 }
1218
1219 if (!checkPermission(
1220 PACLConstants.PORTAL_HOOK_PERMISSION_CUSTOM_JSP_DIR,
1221 portletClassLoader, null, "Rejecting custom JSP directory")) {
1222
1223 return;
1224 }
1225
1226 if (_log.isDebugEnabled()) {
1227 _log.debug("Custom JSP directory: " + customJspDir);
1228 }
1229
1230 boolean customJspGlobal = GetterUtil.getBoolean(
1231 rootElement.elementText("custom-jsp-global"), true);
1232
1233 List<String> customJsps = new ArrayList<String>();
1234
1235 String webDir = servletContext.getRealPath(StringPool.SLASH);
1236
1237 getCustomJsps(servletContext, webDir, customJspDir, customJsps);
1238
1239 if (customJsps.isEmpty()) {
1240 return;
1241 }
1242
1243 CustomJspBag customJspBag = new CustomJspBag(
1244 customJspDir, customJspGlobal, customJsps);
1245
1246 if (_log.isDebugEnabled()) {
1247 StringBundler sb = new StringBundler(customJsps.size() * 2 + 1);
1248
1249 sb.append("Custom JSP files:\n");
1250
1251 for (String customJsp : customJsps) {
1252 sb.append(customJsp);
1253 sb.append(StringPool.NEW_LINE);
1254 }
1255
1256 sb.setIndex(sb.index() - 1);
1257
1258 _log.debug(sb.toString());
1259 }
1260
1261 _customJspBagsMap.put(servletContextName, customJspBag);
1262
1263 initCustomJspBag(
1264 servletContextName, pluginPackage.getName(), customJspBag);
1265 }
1266
1267 protected Object initEvent(
1268 String eventName, String eventClassName,
1269 ClassLoader portletClassLoader)
1270 throws Exception {
1271
1272 if (eventName.equals(APPLICATION_STARTUP_EVENTS)) {
1273 SimpleAction simpleAction =
1274 (SimpleAction)portletClassLoader.loadClass(
1275 eventClassName).newInstance();
1276
1277 simpleAction = new InvokerSimpleAction(
1278 simpleAction, portletClassLoader);
1279
1280 Long companyId = CompanyThreadLocal.getCompanyId();
1281
1282 try {
1283 long[] companyIds = PortalInstances.getCompanyIds();
1284
1285 for (long curCompanyId : companyIds) {
1286 CompanyThreadLocal.setCompanyId(curCompanyId);
1287
1288 simpleAction.run(
1289 new String[] {String.valueOf(curCompanyId)});
1290 }
1291 }
1292 finally {
1293 CompanyThreadLocal.setCompanyId(companyId);
1294 }
1295
1296 return null;
1297 }
1298
1299 if (_propsKeysEvents.contains(eventName)) {
1300 Action action = (Action)portletClassLoader.loadClass(
1301 eventClassName).newInstance();
1302
1303 action = new InvokerAction(action, portletClassLoader);
1304
1305 EventsProcessorUtil.registerEvent(eventName, action);
1306
1307 return action;
1308 }
1309
1310 if (_propsKeysSessionEvents.contains(eventName)) {
1311 SessionAction sessionAction =
1312 (SessionAction)portletClassLoader.loadClass(
1313 eventClassName).newInstance();
1314
1315 sessionAction = new InvokerSessionAction(
1316 sessionAction, portletClassLoader);
1317
1318 EventsProcessorUtil.registerEvent(eventName, sessionAction);
1319
1320 return sessionAction;
1321 }
1322
1323 return null;
1324 }
1325
1326 protected void initEvents(
1327 String servletContextName, ClassLoader portletClassLoader,
1328 Properties portalProperties)
1329 throws Exception {
1330
1331 EventsContainer eventsContainer = new EventsContainer();
1332
1333 _eventsContainerMap.put(servletContextName, eventsContainer);
1334
1335 for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
1336 String key = (String)entry.getKey();
1337
1338 if (!key.equals(APPLICATION_STARTUP_EVENTS) &&
1339 !_propsKeysEvents.contains(key) &&
1340 !_propsKeysSessionEvents.contains(key)) {
1341
1342 continue;
1343 }
1344
1345 String eventName = key;
1346 String[] eventClassNames = StringUtil.split(
1347 (String)entry.getValue());
1348
1349 for (String eventClassName : eventClassNames) {
1350 Object obj = initEvent(
1351 eventName, eventClassName, portletClassLoader);
1352
1353 if (obj == null) {
1354 continue;
1355 }
1356
1357 eventsContainer.registerEvent(eventName, obj);
1358 }
1359 }
1360 }
1361
1362 protected void initHotDeployListeners(
1363 String servletContextName, ClassLoader portletClassLoader,
1364 Properties portalProperties)
1365 throws Exception {
1366
1367 String[] hotDeployListenerClassNames = StringUtil.split(
1368 portalProperties.getProperty(PropsKeys.HOT_DEPLOY_LISTENERS));
1369
1370 if (hotDeployListenerClassNames.length == 0) {
1371 return;
1372 }
1373
1374 HotDeployListenersContainer hotDeployListenersContainer =
1375 new HotDeployListenersContainer();
1376
1377 _hotDeployListenersContainerMap.put(
1378 servletContextName, hotDeployListenersContainer);
1379
1380 for (String hotDeployListenerClassName : hotDeployListenerClassNames) {
1381 HotDeployListener hotDeployListener =
1382 (HotDeployListener)newInstance(
1383 portletClassLoader, HotDeployListener.class,
1384 hotDeployListenerClassName);
1385
1386 hotDeployListenersContainer.registerHotDeployListener(
1387 hotDeployListener);
1388 }
1389 }
1390
1391 protected void initIndexerPostProcessors(
1392 String servletContextName, ClassLoader portletClassLoader,
1393 Element parentElement)
1394 throws Exception {
1395
1396 IndexerPostProcessorContainer indexerPostProcessorContainer =
1397 _indexerPostProcessorContainerMap.get(servletContextName);
1398
1399 if (indexerPostProcessorContainer == null) {
1400 indexerPostProcessorContainer = new IndexerPostProcessorContainer();
1401
1402 _indexerPostProcessorContainerMap.put(
1403 servletContextName, indexerPostProcessorContainer);
1404 }
1405
1406 List<Element> indexerPostProcessorElements = parentElement.elements(
1407 "indexer-post-processor");
1408
1409 for (Element indexerPostProcessorElement :
1410 indexerPostProcessorElements) {
1411
1412 String indexerClassName = indexerPostProcessorElement.elementText(
1413 "indexer-class-name");
1414
1415 if (!checkPermission(
1416 PACLConstants.PORTAL_HOOK_PERMISSION_INDEXER,
1417 portletClassLoader, indexerClassName,
1418 "Rejecting indexer " + indexerClassName)) {
1419
1420 continue;
1421 }
1422
1423 String indexerPostProcessorImpl =
1424 indexerPostProcessorElement.elementText(
1425 "indexer-post-processor-impl");
1426
1427 Indexer indexer = IndexerRegistryUtil.getIndexer(indexerClassName);
1428
1429 if (indexer == null) {
1430 _log.error("No indexer for " + indexerClassName + " was found");
1431
1432 continue;
1433 }
1434
1435 IndexerPostProcessor indexerPostProcessor =
1436 (IndexerPostProcessor)InstanceFactory.newInstance(
1437 portletClassLoader, indexerPostProcessorImpl);
1438
1439 indexer.registerIndexerPostProcessor(indexerPostProcessor);
1440
1441 indexerPostProcessorContainer.registerIndexerPostProcessor(
1442 indexerClassName, indexerPostProcessor);
1443 }
1444 }
1445
1446 protected void initLanguageProperties(
1447 String servletContextName, ClassLoader portletClassLoader,
1448 Element parentElement)
1449 throws Exception {
1450
1451 LanguagesContainer languagesContainer = new LanguagesContainer();
1452
1453 _languagesContainerMap.put(servletContextName, languagesContainer);
1454
1455 List<Element> languagePropertiesElements = parentElement.elements(
1456 "language-properties");
1457
1458 Map<String, String> baseLanguageMap = null;
1459
1460 for (Element languagePropertiesElement : languagePropertiesElements) {
1461 Properties properties = null;
1462
1463 String languagePropertiesLocation =
1464 languagePropertiesElement.getText();
1465
1466 Locale locale = getLocale(languagePropertiesLocation);
1467
1468 if (locale != null) {
1469 if (!checkPermission(
1470 PACLConstants.
1471 PORTAL_HOOK_PERMISSION_LANGUAGE_PROPERTIES_LOCALE,
1472 portletClassLoader, locale,
1473 "Rejecting locale " + locale)) {
1474
1475 continue;
1476 }
1477 }
1478
1479 try {
1480 URL url = portletClassLoader.getResource(
1481 languagePropertiesLocation);
1482
1483 if (url == null) {
1484 continue;
1485 }
1486
1487 InputStream is = url.openStream();
1488
1489 properties = PropertiesUtil.load(is, StringPool.UTF8);
1490
1491 is.close();
1492 }
1493 catch (Exception e) {
1494 _log.error("Unable to read " + languagePropertiesLocation, e);
1495
1496 continue;
1497 }
1498
1499 Map<String, String> languageMap = new HashMap<String, String>();
1500
1501 if (baseLanguageMap != null) {
1502 languageMap.putAll(baseLanguageMap);
1503 }
1504
1505 for (Map.Entry<Object, Object> entry : properties.entrySet()) {
1506 String key = (String)entry.getKey();
1507 String value = (String)entry.getValue();
1508
1509 value = LanguageResources.fixValue(value);
1510
1511 languageMap.put(key, value);
1512 }
1513
1514 if (locale != null) {
1515 languagesContainer.addLanguage(locale, languageMap);
1516 }
1517 else if (!languageMap.isEmpty()) {
1518 baseLanguageMap = languageMap;
1519 }
1520 }
1521
1522 if (baseLanguageMap != null) {
1523 Locale locale = new Locale(StringPool.BLANK);
1524
1525 languagesContainer.addLanguage(locale, baseLanguageMap);
1526 }
1527 }
1528
1529 @SuppressWarnings("rawtypes")
1530 protected ModelListener<BaseModel<?>> initModelListener(
1531 String modelName, String modelListenerClassName,
1532 ClassLoader portletClassLoader)
1533 throws Exception {
1534
1535 ModelListener<BaseModel<?>> modelListener =
1536 (ModelListener<BaseModel<?>>)newInstance(
1537 portletClassLoader, ModelListener.class,
1538 modelListenerClassName);
1539
1540 BasePersistence persistence = getPersistence(modelName);
1541
1542 persistence.registerListener(modelListener);
1543
1544 return modelListener;
1545 }
1546
1547 protected void initModelListeners(
1548 String servletContextName, ClassLoader portletClassLoader,
1549 Properties portalProperties)
1550 throws Exception {
1551
1552 ModelListenersContainer modelListenersContainer =
1553 new ModelListenersContainer();
1554
1555 _modelListenersContainerMap.put(
1556 servletContextName, modelListenersContainer);
1557
1558 for (Map.Entry<Object, Object> entry : portalProperties.entrySet()) {
1559 String key = (String)entry.getKey();
1560
1561 if (!key.startsWith(VALUE_OBJECT_LISTENER)) {
1562 continue;
1563 }
1564
1565 String modelName = key.substring(VALUE_OBJECT_LISTENER.length());
1566
1567 String[] modelListenerClassNames = StringUtil.split(
1568 (String)entry.getValue());
1569
1570 for (String modelListenerClassName : modelListenerClassNames) {
1571 ModelListener<BaseModel<?>> modelListener = initModelListener(
1572 modelName, modelListenerClassName, portletClassLoader);
1573
1574 if (modelListener != null) {
1575 modelListenersContainer.registerModelListener(
1576 modelName, modelListener);
1577 }
1578 }
1579 }
1580 }
1581
1582 protected void initPortalProperties(
1583 String servletContextName, ClassLoader portletClassLoader,
1584 Element parentElement)
1585 throws Exception {
1586
1587 String portalPropertiesLocation = parentElement.elementText(
1588 "portal-properties");
1589
1590 if (Validator.isNull(portalPropertiesLocation)) {
1591 return;
1592 }
1593
1594 Configuration portalPropertiesConfiguration = null;
1595
1596 try {
1597 String name = portalPropertiesLocation;
1598
1599 int pos = name.lastIndexOf(".properties");
1600
1601 if (pos != -1) {
1602 name = name.substring(0, pos);
1603 }
1604
1605 portalPropertiesConfiguration =
1606 ConfigurationFactoryUtil.getConfiguration(
1607 portletClassLoader, name);
1608 }
1609 catch (Exception e) {
1610 _log.error("Unable to read " + portalPropertiesLocation, e);
1611 }
1612
1613 if (portalPropertiesConfiguration == null) {
1614 return;
1615 }
1616
1617 Properties portalProperties =
1618 portalPropertiesConfiguration.getProperties();
1619
1620 if (portalProperties.isEmpty()) {
1621 return;
1622 }
1623
1624 Set<Object> set = portalProperties.keySet();
1625
1626 Iterator<Object> iterator = set.iterator();
1627
1628 while (iterator.hasNext()) {
1629 String key = (String)iterator.next();
1630
1631 if (!checkPermission(
1632 PACLConstants.PORTAL_HOOK_PERMISSION_PORTAL_PROPERTIES_KEY,
1633 portletClassLoader, key,
1634 "Rejecting portal.properties key " + key)) {
1635
1636 iterator.remove();
1637 }
1638 }
1639
1640 Properties unfilteredPortalProperties =
1641 (Properties)portalProperties.clone();
1642
1643 portalProperties.remove(PropsKeys.RELEASE_INFO_BUILD_NUMBER);
1644 portalProperties.remove(PropsKeys.RELEASE_INFO_PREVIOUS_BUILD_NUMBER);
1645 portalProperties.remove(PropsKeys.UPGRADE_PROCESSES);
1646
1647 _portalPropertiesMap.put(servletContextName, portalProperties);
1648
1649
1650
1651
1652
1653 initPortalProperties(
1654 servletContextName, portletClassLoader, portalProperties,
1655 unfilteredPortalProperties);
1656 initAuthFailures(
1657 servletContextName, portletClassLoader, portalProperties);
1658 initAutoDeployListeners(
1659 servletContextName, portletClassLoader, portalProperties);
1660 initAutoLogins(
1661 servletContextName, portletClassLoader, portalProperties);
1662 initAuthenticators(
1663 servletContextName, portletClassLoader, portalProperties);
1664 initAuthVerifiers(
1665 servletContextName, portletClassLoader, portalProperties);
1666 initHotDeployListeners(
1667 servletContextName, portletClassLoader, portalProperties);
1668 initModelListeners(
1669 servletContextName, portletClassLoader, portalProperties);
1670 initEvents(servletContextName, portletClassLoader, portalProperties);
1671 }
1672
1673 protected void initPortalProperties(
1674 String servletContextName, ClassLoader portletClassLoader,
1675 Properties portalProperties, Properties unfilteredPortalProperties)
1676 throws Exception {
1677
1678 PropsUtil.addProperties(portalProperties);
1679
1680 if (_log.isDebugEnabled() && portalProperties.containsKey(LOCALES)) {
1681 _log.debug(
1682 "Portlet locales " + portalProperties.getProperty(LOCALES));
1683 _log.debug("Merged locales " + PropsUtil.get(LOCALES));
1684 _log.debug(
1685 "Merged locales array length " +
1686 PropsUtil.getArray(LOCALES).length);
1687 }
1688
1689 for (String key : _PROPS_VALUES_OBSOLETE) {
1690 if (_log.isInfoEnabled() && portalProperties.contains(key)) {
1691 _log.info("Portal property \"" + key + "\" is obsolete");
1692 }
1693 }
1694
1695 resetPortalProperties(servletContextName, portalProperties, true);
1696
1697 if (portalProperties.containsKey(PropsKeys.AUTH_PUBLIC_PATHS)) {
1698 initAuthPublicPaths(servletContextName, portalProperties);
1699 }
1700
1701 if (portalProperties.containsKey(PropsKeys.AUTH_TOKEN_IMPL)) {
1702 String authTokenClassName = portalProperties.getProperty(
1703 PropsKeys.AUTH_TOKEN_IMPL);
1704
1705 AuthToken authToken = (AuthToken)newInstance(
1706 portletClassLoader, AuthToken.class, authTokenClassName);
1707
1708 AuthTokenWrapper authTokenWrapper =
1709 (AuthTokenWrapper)AuthTokenUtil.getAuthToken();
1710
1711 authTokenWrapper.setAuthToken(authToken);
1712 }
1713
1714 if (portalProperties.containsKey(PropsKeys.CAPTCHA_ENGINE_IMPL)) {
1715 String captchaClassName = portalProperties.getProperty(
1716 PropsKeys.CAPTCHA_ENGINE_IMPL);
1717
1718 Captcha captcha = (Captcha)newInstance(
1719 portletClassLoader, Captcha.class, captchaClassName);
1720
1721 CaptchaImpl captchaImpl = null;
1722
1723 Captcha currentCaptcha = CaptchaUtil.getCaptcha();
1724
1725 if (currentCaptcha instanceof DoPrivilegedBean) {
1726 DoPrivilegedBean doPrivilegedBean =
1727 (DoPrivilegedBean)currentCaptcha;
1728
1729 captchaImpl = (CaptchaImpl)doPrivilegedBean.getActualBean();
1730 }
1731 else {
1732 captchaImpl = (CaptchaImpl)currentCaptcha;
1733 }
1734
1735 captchaImpl.setCaptcha(captcha);
1736 }
1737
1738 if (portalProperties.containsKey(
1739 PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS)) {
1740
1741 String controlPanelEntryClassName = portalProperties.getProperty(
1742 PropsKeys.CONTROL_PANEL_DEFAULT_ENTRY_CLASS);
1743
1744 ControlPanelEntry controlPanelEntry =
1745 (ControlPanelEntry)newInstance(
1746 portletClassLoader, ControlPanelEntry.class,
1747 controlPanelEntryClassName);
1748
1749 DefaultControlPanelEntryFactory.setInstance(controlPanelEntry);
1750 }
1751
1752 if (portalProperties.containsKey(PropsKeys.DL_FILE_ENTRY_PROCESSORS)) {
1753 String[] dlProcessorClassNames = StringUtil.split(
1754 portalProperties.getProperty(
1755 PropsKeys.DL_FILE_ENTRY_PROCESSORS));
1756
1757 DLFileEntryProcessorContainer dlFileEntryProcessorContainer =
1758 new DLFileEntryProcessorContainer();
1759
1760 _dlFileEntryProcessorContainerMap.put(
1761 servletContextName, dlFileEntryProcessorContainer);
1762
1763 for (String dlProcessorClassName : dlProcessorClassNames) {
1764 DLProcessor dlProcessor = (DLProcessor)newInstance(
1765 portletClassLoader, DLProcessor.class,
1766 dlProcessorClassName);
1767
1768 dlFileEntryProcessorContainer.registerDLProcessor(dlProcessor);
1769 }
1770 }
1771
1772 if (portalProperties.containsKey(PropsKeys.DL_REPOSITORY_IMPL)) {
1773 String[] dlRepositoryClassNames = StringUtil.split(
1774 portalProperties.getProperty(PropsKeys.DL_REPOSITORY_IMPL));
1775
1776 DLRepositoryContainer dlRepositoryContainer =
1777 new DLRepositoryContainer();
1778
1779 _dlRepositoryContainerMap.put(
1780 servletContextName, dlRepositoryContainer);
1781
1782 for (String dlRepositoryClassName : dlRepositoryClassNames) {
1783 RepositoryFactory repositoryFactory = new RepositoryFactoryImpl(
1784 dlRepositoryClassName, portletClassLoader);
1785
1786 dlRepositoryContainer.registerRepositoryFactory(
1787 dlRepositoryClassName, repositoryFactory);
1788 }
1789 }
1790
1791 if (portalProperties.containsKey(PropsKeys.DL_STORE_ANTIVIRUS_IMPL)) {
1792 String antivirusScannerClassName = portalProperties.getProperty(
1793 PropsKeys.DL_STORE_ANTIVIRUS_IMPL);
1794
1795 AntivirusScanner antivirusScanner = (AntivirusScanner)newInstance(
1796 portletClassLoader, AntivirusScanner.class,
1797 antivirusScannerClassName);
1798
1799 AntivirusScannerWrapper antivirusScannerWrapper =
1800 (AntivirusScannerWrapper)
1801 AntivirusScannerUtil.getAntivirusScanner();
1802
1803 antivirusScannerWrapper.setAntivirusScanner(antivirusScanner);
1804 }
1805
1806 if (portalProperties.containsKey(PropsKeys.DL_STORE_IMPL)) {
1807 String storeClassName = portalProperties.getProperty(
1808 PropsKeys.DL_STORE_IMPL);
1809
1810 Store store = (Store)newInstance(
1811 portletClassLoader, Store.class, storeClassName);
1812
1813 StoreFactory.setInstance(store);
1814 }
1815
1816 if (portalProperties.containsKey(
1817 PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL)) {
1818
1819 String attributesTransformerClassName =
1820 portalProperties.getProperty(
1821 PropsKeys.LDAP_ATTRS_TRANSFORMER_IMPL);
1822
1823 AttributesTransformer attributesTransformer =
1824 (AttributesTransformer)newInstance(
1825 portletClassLoader, AttributesTransformer.class,
1826 attributesTransformerClassName);
1827
1828 AttributesTransformerFactory.setInstance(attributesTransformer);
1829 }
1830
1831 if (portalProperties.containsKey(LOCK_LISTENERS)) {
1832 LockListenerContainer lockListenerContainer =
1833 _lockListenerContainerMap.get(servletContextName);
1834
1835 if (lockListenerContainer == null) {
1836 lockListenerContainer = new LockListenerContainer();
1837
1838 _lockListenerContainerMap.put(
1839 servletContextName, lockListenerContainer);
1840 }
1841
1842 String[] lockListenerClassNames = StringUtil.split(
1843 portalProperties.getProperty(LOCK_LISTENERS));
1844
1845 for (String lockListenerClassName : lockListenerClassNames) {
1846 LockListener lockListener = (LockListener)newInstance(
1847 portletClassLoader, LockListener.class,
1848 lockListenerClassName);
1849
1850 lockListenerContainer.registerLockListener(lockListener);
1851 }
1852 }
1853
1854 if (portalProperties.containsKey(PropsKeys.MAIL_HOOK_IMPL)) {
1855 String mailHookClassName = portalProperties.getProperty(
1856 PropsKeys.MAIL_HOOK_IMPL);
1857
1858 com.liferay.mail.util.Hook mailHook =
1859 (com.liferay.mail.util.Hook)newInstance(
1860 portletClassLoader, com.liferay.mail.util.Hook.class,
1861 mailHookClassName);
1862
1863 com.liferay.mail.util.HookFactory.setInstance(mailHook);
1864 }
1865
1866 if (portalProperties.containsKey(
1867 PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS)) {
1868
1869 String organizationMembershipPolicyClassName =
1870 portalProperties.getProperty(
1871 PropsKeys.MEMBERSHIP_POLICY_ORGANIZATIONS);
1872
1873 OrganizationMembershipPolicyFactoryImpl
1874 organizationMembershipPolicyFactoryImpl =
1875 (OrganizationMembershipPolicyFactoryImpl)
1876 OrganizationMembershipPolicyFactoryUtil.
1877 getOrganizationMembershipPolicyFactory();
1878
1879 OrganizationMembershipPolicy organizationMembershipPolicy =
1880 (OrganizationMembershipPolicy)newInstance(
1881 portletClassLoader, OrganizationMembershipPolicy.class,
1882 organizationMembershipPolicyClassName);
1883
1884 organizationMembershipPolicyFactoryImpl.
1885 setOrganizationMembershipPolicy(organizationMembershipPolicy);
1886
1887 if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
1888 organizationMembershipPolicy.verifyPolicy();
1889 }
1890 }
1891
1892 if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_ROLES)) {
1893 String roleMembershipPolicyClassName = portalProperties.getProperty(
1894 PropsKeys.MEMBERSHIP_POLICY_ROLES);
1895
1896 RoleMembershipPolicyFactoryImpl roleMembershipPolicyFactoryImpl =
1897 (RoleMembershipPolicyFactoryImpl)
1898 RoleMembershipPolicyFactoryUtil.
1899 getRoleMembershipPolicyFactory();
1900
1901 RoleMembershipPolicy roleMembershipPolicy =
1902 (RoleMembershipPolicy)newInstance(
1903 portletClassLoader, RoleMembershipPolicy.class,
1904 roleMembershipPolicyClassName);
1905
1906 roleMembershipPolicyFactoryImpl.setRoleMembershipPolicy(
1907 roleMembershipPolicy);
1908
1909 if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
1910 roleMembershipPolicy.verifyPolicy();
1911 }
1912 }
1913
1914 if (portalProperties.containsKey(PropsKeys.MEMBERSHIP_POLICY_SITES)) {
1915 String siteMembershipPolicyClassName = portalProperties.getProperty(
1916 PropsKeys.MEMBERSHIP_POLICY_SITES);
1917
1918 SiteMembershipPolicyFactoryImpl siteMembershipPolicyFactoryImpl =
1919 (SiteMembershipPolicyFactoryImpl)
1920 SiteMembershipPolicyFactoryUtil.
1921 getSiteMembershipPolicyFactory();
1922
1923 SiteMembershipPolicy siteMembershipPolicy =
1924 (SiteMembershipPolicy)newInstance(
1925 portletClassLoader, SiteMembershipPolicy.class,
1926 siteMembershipPolicyClassName);
1927
1928 siteMembershipPolicyFactoryImpl.setSiteMembershipPolicy(
1929 siteMembershipPolicy);
1930
1931 if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
1932 siteMembershipPolicy.verifyPolicy();
1933 }
1934 }
1935
1936 if (portalProperties.containsKey(
1937 PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS)) {
1938
1939 String userGroupMembershipPolicyClassName =
1940 portalProperties.getProperty(
1941 PropsKeys.MEMBERSHIP_POLICY_USER_GROUPS);
1942
1943 UserGroupMembershipPolicyFactoryImpl
1944 userGroupMembershipPolicyFactoryImpl =
1945 (UserGroupMembershipPolicyFactoryImpl)
1946 UserGroupMembershipPolicyFactoryUtil.
1947 getUserGroupMembershipPolicyFactory();
1948
1949 UserGroupMembershipPolicy userGroupMembershipPolicy =
1950 (UserGroupMembershipPolicy)newInstance(
1951 portletClassLoader, UserGroupMembershipPolicy.class,
1952 userGroupMembershipPolicyClassName);
1953
1954 userGroupMembershipPolicyFactoryImpl.setUserGroupMembershipPolicy(
1955 userGroupMembershipPolicy);
1956
1957 if (PropsValues.MEMBERSHIP_POLICY_AUTO_VERIFY) {
1958 userGroupMembershipPolicy.verifyPolicy();
1959 }
1960 }
1961
1962 if (portalProperties.containsKey(PropsKeys.PASSWORDS_TOOLKIT)) {
1963 String toolkitClassName = portalProperties.getProperty(
1964 PropsKeys.PASSWORDS_TOOLKIT);
1965
1966 Toolkit toolkit = (Toolkit)newInstance(
1967 portletClassLoader, Sanitizer.class, toolkitClassName);
1968
1969 ToolkitWrapper toolkitWrapper =
1970 (ToolkitWrapper)PwdToolkitUtil.getToolkit();
1971
1972 toolkitWrapper.setToolkit(toolkit);
1973 }
1974
1975 if (portalProperties.containsKey(PropsKeys.PHONE_NUMBER_FORMAT_IMPL)) {
1976 String phoneNumberFormatClassName = portalProperties.getProperty(
1977 PropsKeys.PHONE_NUMBER_FORMAT_IMPL);
1978
1979 PhoneNumberFormat phoneNumberFormat =
1980 (PhoneNumberFormat)newInstance(
1981 portletClassLoader, PhoneNumberFormat.class,
1982 phoneNumberFormatClassName);
1983
1984 PhoneNumberFormatWrapper phoneNumberFormatWrapper =
1985 (PhoneNumberFormatWrapper)
1986 PhoneNumberFormatUtil.getPhoneNumberFormat();
1987
1988 phoneNumberFormatWrapper.setPhoneNumberFormat(phoneNumberFormat);
1989 }
1990
1991 if (portalProperties.containsKey(PropsKeys.SANITIZER_IMPL)) {
1992 String[] sanitizerClassNames = StringUtil.split(
1993 portalProperties.getProperty(PropsKeys.SANITIZER_IMPL));
1994
1995 SanitizerContainer sanitizerContainer = new SanitizerContainer();
1996
1997 _sanitizerContainerMap.put(servletContextName, sanitizerContainer);
1998
1999 for (String sanitizerClassName : sanitizerClassNames) {
2000 Sanitizer sanitizer = (Sanitizer)newInstance(
2001 portletClassLoader, Sanitizer.class, sanitizerClassName);
2002
2003 sanitizerContainer.registerSanitizer(sanitizer);
2004 }
2005 }
2006
2007 if (portalProperties.containsKey(
2008 PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR)) {
2009
2010 String emailAddressGeneratorClassName =
2011 portalProperties.getProperty(
2012 PropsKeys.USERS_EMAIL_ADDRESS_GENERATOR);
2013
2014 EmailAddressGenerator emailAddressGenerator =
2015 (EmailAddressGenerator)newInstance(
2016 portletClassLoader, EmailAddressGenerator.class,
2017 emailAddressGeneratorClassName);
2018
2019 EmailAddressGeneratorFactory.setInstance(emailAddressGenerator);
2020 }
2021
2022 if (portalProperties.containsKey(
2023 PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR)) {
2024
2025 String emailAddressValidatorClassName =
2026 portalProperties.getProperty(
2027 PropsKeys.USERS_EMAIL_ADDRESS_VALIDATOR);
2028
2029 EmailAddressValidator emailAddressValidator =
2030 (EmailAddressValidator)newInstance(
2031 portletClassLoader, EmailAddressValidator.class,
2032 emailAddressValidatorClassName);
2033
2034 EmailAddressValidatorFactory.setInstance(emailAddressValidator);
2035 }
2036
2037 if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_GENERATOR)) {
2038 String fullNameGeneratorClassName = portalProperties.getProperty(
2039 PropsKeys.USERS_FULL_NAME_GENERATOR);
2040
2041 FullNameGenerator fullNameGenerator =
2042 (FullNameGenerator)newInstance(
2043 portletClassLoader, FullNameGenerator.class,
2044 fullNameGeneratorClassName);
2045
2046 FullNameGeneratorFactory.setInstance(fullNameGenerator);
2047 }
2048
2049 if (portalProperties.containsKey(PropsKeys.USERS_FULL_NAME_VALIDATOR)) {
2050 String fullNameValidatorClassName = portalProperties.getProperty(
2051 PropsKeys.USERS_FULL_NAME_VALIDATOR);
2052
2053 FullNameValidator fullNameValidator =
2054 (FullNameValidator)newInstance(
2055 portletClassLoader, FullNameValidator.class,
2056 fullNameValidatorClassName);
2057
2058 FullNameValidatorFactory.setInstance(fullNameValidator);
2059 }
2060
2061 if (portalProperties.containsKey(
2062 PropsKeys.USERS_SCREEN_NAME_GENERATOR)) {
2063
2064 String screenNameGeneratorClassName = portalProperties.getProperty(
2065 PropsKeys.USERS_SCREEN_NAME_GENERATOR);
2066
2067 ScreenNameGenerator screenNameGenerator =
2068 (ScreenNameGenerator)newInstance(
2069 portletClassLoader, ScreenNameGenerator.class,
2070 screenNameGeneratorClassName);
2071
2072 ScreenNameGeneratorFactory.setInstance(screenNameGenerator);
2073 }
2074
2075 if (portalProperties.containsKey(
2076 PropsKeys.USERS_SCREEN_NAME_VALIDATOR)) {
2077
2078 String screenNameValidatorClassName = portalProperties.getProperty(
2079 PropsKeys.USERS_SCREEN_NAME_VALIDATOR);
2080
2081 ScreenNameValidator screenNameValidator =
2082 (ScreenNameValidator)newInstance(
2083 portletClassLoader, ScreenNameValidator.class,
2084 screenNameValidatorClassName);
2085
2086 ScreenNameValidatorFactory.setInstance(screenNameValidator);
2087 }
2088
2089 Set<String> liferayFilterClassNames =
2090 LiferayFilterTracker.getClassNames();
2091
2092 for (String liferayFilterClassName : liferayFilterClassNames) {
2093 if (!portalProperties.containsKey(liferayFilterClassName)) {
2094 continue;
2095 }
2096
2097 boolean filterEnabled = GetterUtil.getBoolean(
2098 portalProperties.getProperty(liferayFilterClassName));
2099
2100 Set<LiferayFilter> liferayFilters =
2101 LiferayFilterTracker.getLiferayFilters(liferayFilterClassName);
2102
2103 for (LiferayFilter liferayFilter : liferayFilters) {
2104 liferayFilter.setFilterEnabled(filterEnabled);
2105 }
2106 }
2107
2108 if (unfilteredPortalProperties.containsKey(
2109 PropsKeys.RELEASE_INFO_BUILD_NUMBER) ||
2110 unfilteredPortalProperties.containsKey(
2111 PropsKeys.UPGRADE_PROCESSES)) {
2112
2113 updateRelease(
2114 servletContextName, portletClassLoader,
2115 unfilteredPortalProperties);
2116 }
2117 }
2118
2119 protected void initServices(
2120 String servletContextName, ClassLoader portletClassLoader,
2121 String serviceType, Class<?> serviceTypeClass,
2122 Constructor<?> serviceImplConstructor, Object serviceProxy)
2123 throws Exception {
2124
2125 AdvisedSupport advisedSupport = ServiceBeanAopProxy.getAdvisedSupport(
2126 serviceProxy);
2127
2128 TargetSource targetSource = advisedSupport.getTargetSource();
2129
2130 Object previousService = targetSource.getTarget();
2131
2132 if (ProxyUtil.isProxyClass(previousService.getClass())) {
2133 InvocationHandler invocationHandler =
2134 ProxyUtil.getInvocationHandler(previousService);
2135
2136 if (invocationHandler instanceof ClassLoaderBeanHandler) {
2137 ClassLoaderBeanHandler classLoaderBeanHandler =
2138 (ClassLoaderBeanHandler)invocationHandler;
2139
2140 previousService = classLoaderBeanHandler.getBean();
2141 }
2142 }
2143
2144 Object nextService = serviceImplConstructor.newInstance(
2145 previousService);
2146
2147 Object nextTarget = ProxyUtil.newProxyInstance(
2148 portletClassLoader, new Class<?>[] {serviceTypeClass},
2149 new ClassLoaderBeanHandler(nextService, portletClassLoader));
2150
2151 TargetSource nextTargetSource = new SingletonTargetSource(nextTarget);
2152
2153 advisedSupport.setTargetSource(nextTargetSource);
2154
2155 _servicesContainer.addServiceBag(
2156 servletContextName, portletClassLoader, serviceType,
2157 serviceTypeClass, serviceImplConstructor, previousService);
2158
2159 ServiceBeanAopCacheManagerUtil.reset();
2160 }
2161
2162 protected Filter initServletFilter(
2163 String filterClassName, ClassLoader portletClassLoader)
2164 throws Exception {
2165
2166 Filter filter = (Filter)InstanceFactory.newInstance(
2167 portletClassLoader, filterClassName);
2168
2169 List<Class<?>> interfaces = new ArrayList<Class<?>>();
2170
2171 if (filter instanceof TryFilter) {
2172 interfaces.add(TryFilter.class);
2173 }
2174
2175 if (filter instanceof TryFinallyFilter) {
2176 interfaces.add(TryFinallyFilter.class);
2177 }
2178
2179 if (filter instanceof WrapHttpServletRequestFilter) {
2180 interfaces.add(WrapHttpServletRequestFilter.class);
2181 }
2182
2183 if (filter instanceof WrapHttpServletResponseFilter) {
2184 interfaces.add(WrapHttpServletResponseFilter.class);
2185 }
2186
2187 if (filter instanceof LiferayFilter) {
2188 interfaces.add(LiferayFilter.class);
2189 }
2190 else {
2191 interfaces.add(Filter.class);
2192 }
2193
2194 filter = (Filter)ProxyUtil.newProxyInstance(
2195 portletClassLoader,
2196 interfaces.toArray(new Class[interfaces.size()]),
2197 new ClassLoaderBeanHandler(filter, portletClassLoader));
2198
2199 return filter;
2200 }
2201
2202 protected void initServletFilters(
2203 ServletContext servletContext, String servletContextName,
2204 ClassLoader portletClassLoader, Element parentElement)
2205 throws Exception {
2206
2207 ServletFiltersContainer servletFiltersContainer =
2208 _servletFiltersContainerMap.get(servletContextName);
2209
2210 if (servletFiltersContainer == null) {
2211 servletFiltersContainer = new ServletFiltersContainer();
2212
2213 _servletFiltersContainerMap.put(
2214 servletContextName, servletFiltersContainer);
2215 }
2216
2217 List<Element> servletFilterElements = parentElement.elements(
2218 "servlet-filter");
2219
2220 if (!servletFilterElements.isEmpty() &&
2221 !checkPermission(
2222 PACLConstants.PORTAL_HOOK_PERMISSION_SERVLET_FILTERS,
2223 portletClassLoader, null, "Rejecting servlet filters")) {
2224
2225 return;
2226 }
2227
2228 for (Element servletFilterElement : servletFilterElements) {
2229 String servletFilterName = servletFilterElement.elementText(
2230 "servlet-filter-name");
2231 String servletFilterImpl = servletFilterElement.elementText(
2232 "servlet-filter-impl");
2233
2234 List<Element> initParamElements = servletFilterElement.elements(
2235 "init-param");
2236
2237 Map<String, String> initParameterMap =
2238 new HashMap<String, String>();
2239
2240 for (Element initParamElement : initParamElements) {
2241 String paramName = initParamElement.elementText("param-name");
2242 String paramValue = initParamElement.elementText("param-value");
2243
2244 initParameterMap.put(paramName, paramValue);
2245 }
2246
2247 Filter filter = initServletFilter(
2248 servletFilterImpl, portletClassLoader);
2249
2250 FilterConfig filterConfig = new InvokerFilterConfig(
2251 servletContext, servletFilterName, initParameterMap);
2252
2253 filter.init(filterConfig);
2254
2255 servletFiltersContainer.registerFilter(
2256 servletFilterName, filter, filterConfig);
2257 }
2258
2259 List<Element> servletFilterMappingElements = parentElement.elements(
2260 "servlet-filter-mapping");
2261
2262 for (Element servletFilterMappingElement :
2263 servletFilterMappingElements) {
2264
2265 String servletFilterName = servletFilterMappingElement.elementText(
2266 "servlet-filter-name");
2267 String afterFilter = servletFilterMappingElement.elementText(
2268 "after-filter");
2269 String beforeFilter = servletFilterMappingElement.elementText(
2270 "before-filter");
2271
2272 String positionFilterName = beforeFilter;
2273 boolean after = false;
2274
2275 if (Validator.isNotNull(afterFilter)) {
2276 positionFilterName = afterFilter;
2277 after = true;
2278 }
2279
2280 List<Element> urlPatternElements =
2281 servletFilterMappingElement.elements("url-pattern");
2282
2283 List<String> urlPatterns = new ArrayList<String>();
2284
2285 for (Element urlPatternElement : urlPatternElements) {
2286 String urlPattern = urlPatternElement.getTextTrim();
2287
2288 urlPatterns.add(urlPattern);
2289 }
2290
2291 List<Element> dispatcherElements =
2292 servletFilterMappingElement.elements("dispatcher");
2293
2294 List<String> dispatchers = new ArrayList<String>();
2295
2296 for (Element dispatcherElement : dispatcherElements) {
2297 String dispatcher = dispatcherElement.getTextTrim();
2298
2299 dispatcher = dispatcher.toUpperCase();
2300
2301 dispatchers.add(dispatcher);
2302 }
2303
2304 servletFiltersContainer.registerFilterMapping(
2305 servletFilterName, urlPatterns, dispatchers, positionFilterName,
2306 after);
2307 }
2308 }
2309
2310 protected Object initStrutsAction(
2311 String strutsActionClassName, ClassLoader portletClassLoader)
2312 throws Exception {
2313
2314 Object strutsAction = InstanceFactory.newInstance(
2315 portletClassLoader, strutsActionClassName);
2316
2317 if (strutsAction instanceof StrutsAction) {
2318 return ProxyUtil.newProxyInstance(
2319 portletClassLoader, new Class[] {StrutsAction.class},
2320 new ClassLoaderBeanHandler(strutsAction, portletClassLoader));
2321 }
2322 else {
2323 return ProxyUtil.newProxyInstance(
2324 portletClassLoader, new Class[] {StrutsPortletAction.class},
2325 new ClassLoaderBeanHandler(strutsAction, portletClassLoader));
2326 }
2327 }
2328
2329 protected void initStrutsActions(
2330 String servletContextName, ClassLoader portletClassLoader,
2331 Element parentElement)
2332 throws Exception {
2333
2334 StrutsActionsContainer strutsActionContainer =
2335 _strutsActionsContainerMap.get(servletContextName);
2336
2337 if (strutsActionContainer == null) {
2338 strutsActionContainer = new StrutsActionsContainer();
2339
2340 _strutsActionsContainerMap.put(
2341 servletContextName, strutsActionContainer);
2342 }
2343
2344 List<Element> strutsActionElements = parentElement.elements(
2345 "struts-action");
2346
2347 for (Element strutsActionElement : strutsActionElements) {
2348 String strutsActionPath = strutsActionElement.elementText(
2349 "struts-action-path");
2350
2351 if (!checkPermission(
2352 PACLConstants.PORTAL_HOOK_PERMISSION_STRUTS_ACTION_PATH,
2353 portletClassLoader, strutsActionPath,
2354 "Rejecting struts action path " + strutsActionPath)) {
2355
2356 continue;
2357 }
2358
2359 String strutsActionImpl = strutsActionElement.elementText(
2360 "struts-action-impl");
2361
2362 Object strutsAction = initStrutsAction(
2363 strutsActionImpl, portletClassLoader);
2364
2365 strutsActionContainer.registerStrutsAction(
2366 strutsActionPath, strutsAction);
2367 }
2368 }
2369
2370 protected void resetPortalProperties(
2371 String servletContextName, Properties portalProperties,
2372 boolean initPhase)
2373 throws Exception {
2374
2375 for (String key : _PROPS_VALUES_BOOLEAN) {
2376 String fieldName = StringUtil.replace(
2377 key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2378
2379 if (!containsKey(portalProperties, key)) {
2380 continue;
2381 }
2382
2383 try {
2384 Field field = PropsValues.class.getField(fieldName);
2385
2386 Boolean value = Boolean.valueOf(
2387 GetterUtil.getBoolean(PropsUtil.get(key)));
2388
2389 field.setBoolean(null, value);
2390 }
2391 catch (Exception e) {
2392 _log.error(
2393 "Error setting field " + fieldName + ": " + e.getMessage());
2394 }
2395 }
2396
2397 for (String key : _PROPS_VALUES_INTEGER) {
2398 String fieldName = StringUtil.replace(
2399 key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2400
2401 if (!containsKey(portalProperties, key)) {
2402 continue;
2403 }
2404
2405 try {
2406 Field field = PropsValues.class.getField(fieldName);
2407
2408 Integer value = Integer.valueOf(
2409 GetterUtil.getInteger(PropsUtil.get(key)));
2410
2411 field.setInt(null, value);
2412 }
2413 catch (Exception e) {
2414 _log.error(
2415 "Error setting field " + fieldName + ": " + e.getMessage());
2416 }
2417 }
2418
2419 for (String key : _PROPS_VALUES_LONG) {
2420 String fieldName = StringUtil.replace(
2421 key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2422
2423 if (!containsKey(portalProperties, key)) {
2424 continue;
2425 }
2426
2427 try {
2428 Field field = PropsValues.class.getField(fieldName);
2429
2430 Long value = Long.valueOf(
2431 GetterUtil.getLong(PropsUtil.get(key)));
2432
2433 field.setLong(null, value);
2434 }
2435 catch (Exception e) {
2436 _log.error(
2437 "Error setting field " + fieldName + ": " + e.getMessage());
2438 }
2439 }
2440
2441 for (String key : _PROPS_VALUES_STRING) {
2442 String fieldName = StringUtil.replace(
2443 key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2444
2445 if (!containsKey(portalProperties, key)) {
2446 continue;
2447 }
2448
2449 try {
2450 Field field = PropsValues.class.getField(fieldName);
2451
2452 String value = GetterUtil.getString(PropsUtil.get(key));
2453
2454 field.set(null, value);
2455 }
2456 catch (Exception e) {
2457 _log.error(
2458 "Error setting field " + fieldName + ": " + e.getMessage());
2459 }
2460 }
2461
2462 resetPortalPropertiesStringArray(
2463 servletContextName, portalProperties, initPhase,
2464 _PROPS_VALUES_MERGE_STRING_ARRAY, _mergeStringArraysContainerMap);
2465
2466 resetPortalPropertiesStringArray(
2467 servletContextName, portalProperties, initPhase,
2468 _PROPS_VALUES_OVERRIDE_STRING_ARRAY,
2469 _overrideStringArraysContainerMap);
2470
2471 if (containsKey(portalProperties, LOCALES) ||
2472 containsKey(portalProperties, LOCALES_BETA)) {
2473
2474 PropsValues.LOCALES = PropsUtil.getArray(LOCALES);
2475
2476 LanguageUtil.init();
2477 }
2478
2479 if (containsKey(portalProperties, LOCALES_ENABLED)) {
2480 PropsValues.LOCALES_ENABLED = PropsUtil.getArray(LOCALES_ENABLED);
2481
2482 LanguageUtil.init();
2483 }
2484
2485 if (containsKey(portalProperties, AUTH_TOKEN_IGNORE_ACTIONS)) {
2486 AuthTokenWhitelistUtil.resetPortletCSRFWhitelistActions();
2487 }
2488
2489 if (containsKey(portalProperties, AUTH_TOKEN_IGNORE_PORTLETS)) {
2490 AuthTokenWhitelistUtil.resetPortletCSRFWhitelist();
2491 }
2492
2493 if (containsKey(
2494 portalProperties,
2495 PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST)) {
2496
2497 AuthTokenWhitelistUtil.resetPortletInvocationWhitelist();
2498 }
2499
2500 if (containsKey(
2501 portalProperties,
2502 PORTLET_ADD_DEFAULT_RESOURCE_CHECK_WHITELIST_ACTIONS)) {
2503
2504 AuthTokenWhitelistUtil.resetPortletInvocationWhitelistActions();
2505 }
2506
2507 CacheUtil.clearCache();
2508
2509 JavaScriptBundleUtil.clearCache();
2510 }
2511
2512 protected void resetPortalPropertiesStringArray(
2513 String servletContextName, Properties portalProperties,
2514 boolean initPhase, String[] propsValuesStringArray,
2515 Map<String, StringArraysContainer> stringArraysContainerMap) {
2516
2517 for (String key : propsValuesStringArray) {
2518 String fieldName = StringUtil.replace(
2519 key.toUpperCase(), CharPool.PERIOD, CharPool.UNDERLINE);
2520
2521 if (!containsKey(portalProperties, key)) {
2522 continue;
2523 }
2524
2525 try {
2526 resetPortalPropertiesStringArray(
2527 servletContextName, portalProperties, initPhase,
2528 propsValuesStringArray, stringArraysContainerMap, key,
2529 fieldName);
2530 }
2531 catch (Exception e) {
2532 _log.error(
2533 "Error setting field " + fieldName + ": " + e.getMessage());
2534 }
2535 }
2536 }
2537
2538 protected void resetPortalPropertiesStringArray(
2539 String servletContextName, Properties portalProperties,
2540 boolean initPhase, String[] propsValuesStringArray,
2541 Map<String, StringArraysContainer> stringArraysContainerMap,
2542 String key, String fieldName)
2543 throws Exception {
2544
2545 Field field = PropsValues.class.getField(fieldName);
2546
2547 StringArraysContainer stringArraysContainer =
2548 stringArraysContainerMap.get(key);
2549
2550 String[] value = null;
2551
2552 if (initPhase) {
2553 if (stringArraysContainer
2554 instanceof OverrideStringArraysContainer) {
2555
2556 OverrideStringArraysContainer overrideStringArraysContainer =
2557 (OverrideStringArraysContainer)stringArraysContainer;
2558
2559 if (overrideStringArraysContainer.isOverridden()) {
2560 _log.error("Error setting overridden field " + fieldName);
2561
2562 return;
2563 }
2564
2565 value = StringUtil.split(portalProperties.getProperty(key));
2566 }
2567 else {
2568 value = PropsUtil.getArray(key);
2569 }
2570 }
2571
2572 stringArraysContainer.setPluginStringArray(servletContextName, value);
2573
2574 value = stringArraysContainer.getStringArray();
2575
2576 field.set(null, value);
2577 }
2578
2579 protected void updateRelease(
2580 String servletContextName, ClassLoader portletClassLoader,
2581 Properties unfilteredPortalProperties)
2582 throws Exception {
2583
2584 int buildNumber = GetterUtil.getInteger(
2585 unfilteredPortalProperties.getProperty(
2586 PropsKeys.RELEASE_INFO_BUILD_NUMBER));
2587
2588 if (buildNumber <= 0) {
2589 _log.error(
2590 "Skipping upgrade processes for " + servletContextName +
2591 " because \"release.info.build.number\" is not specified");
2592
2593 return;
2594 }
2595
2596 Release release = ReleaseLocalServiceUtil.fetchRelease(
2597 servletContextName);
2598
2599 if (release == null) {
2600 int previousBuildNumber = GetterUtil.getInteger(
2601 unfilteredPortalProperties.getProperty(
2602 PropsKeys.RELEASE_INFO_PREVIOUS_BUILD_NUMBER),
2603 buildNumber);
2604
2605 release = ReleaseLocalServiceUtil.addRelease(
2606 servletContextName, previousBuildNumber);
2607 }
2608
2609 if (buildNumber == release.getBuildNumber()) {
2610 if (_log.isDebugEnabled()) {
2611 _log.debug(
2612 "Skipping upgrade processes for " + servletContextName +
2613 " because it is already up to date");
2614 }
2615 }
2616 else if (buildNumber < release.getBuildNumber()) {
2617 throw new UpgradeException(
2618 "Skipping upgrade processes for " + servletContextName +
2619 " because you are trying to upgrade with an older version");
2620 }
2621 else {
2622 String[] upgradeProcessClassNames = StringUtil.split(
2623 unfilteredPortalProperties.getProperty(
2624 PropsKeys.UPGRADE_PROCESSES));
2625
2626 boolean indexOnUpgrade = GetterUtil.getBoolean(
2627 unfilteredPortalProperties.getProperty(
2628 PropsKeys.INDEX_ON_UPGRADE),
2629 PropsValues.INDEX_ON_UPGRADE);
2630
2631 UpgradeProcessUtil.upgradeProcess(
2632 release.getBuildNumber(), upgradeProcessClassNames,
2633 portletClassLoader, indexOnUpgrade);
2634 }
2635
2636 ReleaseLocalServiceUtil.updateRelease(
2637 release.getReleaseId(), buildNumber, null, true);
2638 }
2639
2640 private static final String[] _PROPS_KEYS_EVENTS = {
2641 LOGIN_EVENTS_POST, LOGIN_EVENTS_PRE, LOGOUT_EVENTS_POST,
2642 LOGOUT_EVENTS_PRE, SERVLET_SERVICE_EVENTS_POST,
2643 SERVLET_SERVICE_EVENTS_PRE
2644 };
2645
2646 private static final String[] _PROPS_KEYS_SESSION_EVENTS = {
2647 SERVLET_SESSION_CREATE_EVENTS, SERVLET_SESSION_DESTROY_EVENTS
2648 };
2649
2650 private static final String[] _PROPS_VALUES_BOOLEAN = {
2651 "auth.forward.by.last.path", "captcha.check.portal.create_account",
2652 "dl.file.entry.drafts.enabled",
2653 "dl.file.entry.open.in.ms.office.manual.check.in.required",
2654 "field.enable.com.liferay.portal.model.Contact.birthday",
2655 "field.enable.com.liferay.portal.model.Contact.male",
2656 "field.enable.com.liferay.portal.model.Organization.status",
2657 "javascript.fast.load", "layout.template.cache.enabled",
2658 "layout.user.private.layouts.auto.create",
2659 "layout.user.private.layouts.enabled",
2660 "layout.user.private.layouts.power.user.required",
2661 "layout.user.public.layouts.auto.create",
2662 "layout.user.public.layouts.enabled",
2663 "layout.user.public.layouts.power.user.required",
2664 "login.create.account.allow.custom.password",
2665 "my.sites.show.private.sites.with.no.layouts",
2666 "my.sites.show.public.sites.with.no.layouts",
2667 "my.sites.show.user.private.sites.with.no.layouts",
2668 "my.sites.show.user.public.sites.with.no.layouts",
2669 "portlet.add.default.resource.check.enabled", "rss.feeds.enabled",
2670 "session.store.password", "social.activity.sets.bundling.enabled",
2671 "social.activity.sets.enabled", "terms.of.use.required",
2672 "theme.css.fast.load", "theme.images.fast.load",
2673 "theme.jsp.override.enabled", "theme.loader.new.theme.id.on.import",
2674 "theme.portlet.decorate.default", "theme.portlet.sharing.default",
2675 "user.notification.event.confirmation.enabled",
2676 "users.email.address.required", "users.screen.name.always.autogenerate"
2677 };
2678
2679 private static final String[] _PROPS_VALUES_INTEGER = {
2680 "session.max.allowed", "users.image.max.height",
2681 "users.image.max.width",
2682 };
2683
2684 private static final String[] _PROPS_VALUES_LONG = {
2685 };
2686
2687 private static final String[] _PROPS_VALUES_MERGE_STRING_ARRAY = {
2688 "auth.token.ignore.actions", "auth.token.ignore.portlets",
2689 "admin.default.group.names", "admin.default.role.names",
2690 "admin.default.user.group.names", "asset.publisher.display.styles",
2691 "company.settings.form.authentication",
2692 "company.settings.form.configuration",
2693 "company.settings.form.identification",
2694 "company.settings.form.miscellaneous", "convert.processes",
2695 "dockbar.add.portlets", "journal.article.form.add",
2696 "journal.article.form.translate", "journal.article.form.update",
2697 "layout.form.add", "layout.form.update", "layout.set.form.update",
2698 "layout.static.portlets.all", "layout.types",
2699 "login.form.navigation.post", "login.form.navigation.pre",
2700 "organizations.form.add.identification", "organizations.form.add.main",
2701 "organizations.form.add.miscellaneous",
2702 "portlet.add.default.resource.check.whitelist",
2703 "portlet.add.default.resource.check.whitelist.actions",
2704 "session.phishing.protected.attributes", "sites.form.add.advanced",
2705 "sites.form.add.main", "sites.form.add.seo",
2706 "sites.form.update.advanced", "sites.form.update.main",
2707 "sites.form.update.seo", "users.form.add.identification",
2708 "users.form.add.main", "users.form.add.miscellaneous",
2709 "users.form.my.account.identification", "users.form.my.account.main",
2710 "users.form.my.account.miscellaneous",
2711 "users.form.update.identification", "users.form.update.main",
2712 "users.form.update.miscellaneous"
2713 };
2714
2715 private static final String[] _PROPS_VALUES_OBSOLETE = {
2716 "layout.user.private.layouts.modifiable",
2717 "layout.user.public.layouts.modifiable"
2718 };
2719
2720 private static final String[] _PROPS_VALUES_OVERRIDE_STRING_ARRAY = {
2721 "locales.beta"
2722 };
2723
2724 private static final String[] _PROPS_VALUES_STRING = {
2725 "company.default.locale", "company.default.time.zone",
2726 "default.landing.page.path", "default.regular.color.scheme.id",
2727 "default.regular.theme.id", "default.wap.color.scheme.id",
2728 "default.wap.theme.id", "passwords.passwordpolicytoolkit.generator",
2729 "passwords.passwordpolicytoolkit.static",
2730 "phone.number.format.international.regexp",
2731 "phone.number.format.usa.regexp", "social.activity.sets.selector",
2732 "theme.shortcut.icon"
2733 };
2734
2735 private static Log _log = LogFactoryUtil.getLog(
2736 HookHotDeployListener.class);
2737
2738 private Map<String, AuthenticatorsContainer> _authenticatorsContainerMap =
2739 new HashMap<String, AuthenticatorsContainer>();
2740 private Map<String, AuthFailuresContainer> _authFailuresContainerMap =
2741 new HashMap<String, AuthFailuresContainer>();
2742 private Map<String, AuthPublicPathsContainer> _authPublicPathsContainerMap =
2743 new HashMap<String, AuthPublicPathsContainer>();
2744 private Map<String, AuthVerifierConfigurationContainer>
2745 _authVerifierConfigurationContainerMap =
2746 new HashMap<String, AuthVerifierConfigurationContainer>();
2747 private Map<String, AutoDeployListenersContainer>
2748 _autoDeployListenersContainerMap =
2749 new HashMap<String, AutoDeployListenersContainer>();
2750 private Map<String, AutoLoginsContainer> _autoLoginsContainerMap =
2751 new HashMap<String, AutoLoginsContainer>();
2752 private Map<String, CustomJspBag> _customJspBagsMap =
2753 new HashMap<String, CustomJspBag>();
2754 private Map<String, DLFileEntryProcessorContainer>
2755 _dlFileEntryProcessorContainerMap =
2756 new HashMap<String, DLFileEntryProcessorContainer>();
2757 private Map<String, DLRepositoryContainer> _dlRepositoryContainerMap =
2758 new HashMap<String, DLRepositoryContainer>();
2759 private Map<String, EventsContainer> _eventsContainerMap =
2760 new HashMap<String, EventsContainer>();
2761 private Map<String, HotDeployListenersContainer>
2762 _hotDeployListenersContainerMap =
2763 new HashMap<String, HotDeployListenersContainer>();
2764 private Map<String, IndexerPostProcessorContainer>
2765 _indexerPostProcessorContainerMap =
2766 new HashMap<String, IndexerPostProcessorContainer>();
2767 private Map<String, LanguagesContainer> _languagesContainerMap =
2768 new HashMap<String, LanguagesContainer>();
2769 private Map<String, LockListenerContainer> _lockListenerContainerMap =
2770 new HashMap<String, LockListenerContainer>();
2771 private Map<String, StringArraysContainer> _mergeStringArraysContainerMap =
2772 new HashMap<String, StringArraysContainer>();
2773 private Map<String, ModelListenersContainer> _modelListenersContainerMap =
2774 new HashMap<String, ModelListenersContainer>();
2775 private Map<String, StringArraysContainer>
2776 _overrideStringArraysContainerMap =
2777 new HashMap<String, StringArraysContainer>();
2778 private Map<String, Properties> _portalPropertiesMap =
2779 new HashMap<String, Properties>();
2780 private Set<String> _propsKeysEvents = SetUtil.fromArray(
2781 _PROPS_KEYS_EVENTS);
2782 private Set<String> _propsKeysSessionEvents = SetUtil.fromArray(
2783 _PROPS_KEYS_SESSION_EVENTS);
2784 private Map<String, SanitizerContainer> _sanitizerContainerMap =
2785 new HashMap<String, SanitizerContainer>();
2786 private ServicesContainer _servicesContainer = new ServicesContainer();
2787 private Set<String> _servletContextNames = new HashSet<String>();
2788 private Map<String, ServletFiltersContainer> _servletFiltersContainerMap =
2789 new HashMap<String, ServletFiltersContainer>();
2790 private Map<String, StrutsActionsContainer> _strutsActionsContainerMap =
2791 new HashMap<String, StrutsActionsContainer>();
2792
2793 private class AuthenticatorsContainer {
2794
2795 public void registerAuthenticator(
2796 String key, Authenticator authenticator) {
2797
2798 List<Authenticator> authenticators = _authenticators.get(key);
2799
2800 if (authenticators == null) {
2801 authenticators = new ArrayList<Authenticator>();
2802
2803 _authenticators.put(key, authenticators);
2804 }
2805
2806 AuthPipeline.registerAuthenticator(key, authenticator);
2807
2808 authenticators.add(authenticator);
2809 }
2810
2811 public void unregisterAuthenticators() {
2812 for (Map.Entry<String, List<Authenticator>> entry :
2813 _authenticators.entrySet()) {
2814
2815 String key = entry.getKey();
2816 List<Authenticator> authenticators = entry.getValue();
2817
2818 for (Authenticator authenticator : authenticators) {
2819 AuthPipeline.unregisterAuthenticator(key, authenticator);
2820 }
2821 }
2822 }
2823
2824 private Map<String, List<Authenticator>> _authenticators =
2825 new HashMap<String, List<Authenticator>>();
2826
2827 }
2828
2829 private class AuthFailuresContainer {
2830
2831 public void registerAuthFailure(String key, AuthFailure authFailure) {
2832 List<AuthFailure> authFailures = _authFailures.get(key);
2833
2834 if (authFailures == null) {
2835 authFailures = new ArrayList<AuthFailure>();
2836
2837 _authFailures.put(key, authFailures);
2838 }
2839
2840 AuthPipeline.registerAuthFailure(key, authFailure);
2841
2842 authFailures.add(authFailure);
2843 }
2844
2845 public void unregisterAuthFailures() {
2846 for (Map.Entry<String, List<AuthFailure>> entry :
2847 _authFailures.entrySet()) {
2848
2849 String key = entry.getKey();
2850 List<AuthFailure> authFailures = entry.getValue();
2851
2852 for (AuthFailure authFailure : authFailures) {
2853 AuthPipeline.unregisterAuthFailure(key, authFailure);
2854 }
2855 }
2856 }
2857
2858 private Map<String, List<AuthFailure>> _authFailures =
2859 new HashMap<String, List<AuthFailure>>();
2860
2861 }
2862
2863 private class AuthPublicPathsContainer {
2864
2865 public void registerPaths(String[] paths) {
2866 for (String path : paths) {
2867 _paths.add(path);
2868 }
2869
2870 AuthPublicPathRegistry.register(paths);
2871 }
2872
2873 public void unregisterPaths() {
2874 for (String path : _paths) {
2875 AuthPublicPathRegistry.unregister(path);
2876 }
2877
2878 _paths.clear();
2879 }
2880
2881 private Set<String> _paths = new HashSet<String>();
2882
2883 }
2884
2885 private class AuthVerifierConfigurationContainer {
2886
2887 public void registerAuthVerifierConfiguration(
2888 AuthVerifierConfiguration authVerifierConfiguration) {
2889
2890 AuthVerifierPipeline.register(authVerifierConfiguration);
2891
2892 _authVerifierConfigurations.add(authVerifierConfiguration);
2893 }
2894
2895 public void unregisterConfigurations() {
2896 for (AuthVerifierConfiguration authVerifierConfiguration :
2897 _authVerifierConfigurations) {
2898
2899 AuthVerifierPipeline.unregister(authVerifierConfiguration);
2900 }
2901 }
2902
2903 private List<AuthVerifierConfiguration> _authVerifierConfigurations =
2904 new ArrayList<AuthVerifierConfiguration>();
2905
2906 }
2907
2908 private class AutoDeployListenersContainer {
2909
2910 public void registerAutoDeployListener(
2911 AutoDeployListener autoDeployListener) {
2912
2913 AutoDeployDir autoDeployDir = AutoDeployUtil.getDir(
2914 AutoDeployDir.DEFAULT_NAME);
2915
2916 if (autoDeployDir == null) {
2917 return;
2918 }
2919
2920 autoDeployDir.registerListener(autoDeployListener);
2921
2922 _autoDeployListeners.add(autoDeployListener);
2923 }
2924
2925 public void unregisterAutoDeployListeners() {
2926 AutoDeployDir autoDeployDir = AutoDeployUtil.getDir(
2927 AutoDeployDir.DEFAULT_NAME);
2928
2929 if (autoDeployDir == null) {
2930 return;
2931 }
2932
2933 for (AutoDeployListener autoDeployListener : _autoDeployListeners) {
2934 autoDeployDir.unregisterListener(autoDeployListener);
2935 }
2936 }
2937
2938 private List<AutoDeployListener> _autoDeployListeners =
2939 new ArrayList<AutoDeployListener>();
2940
2941 }
2942
2943 private class AutoLoginsContainer {
2944
2945 public void registerAutoLogin(AutoLogin autoLogin) {
2946 AutoLoginFilter.registerAutoLogin(autoLogin);
2947
2948 _autoLogins.add(autoLogin);
2949 }
2950
2951 public void unregisterAutoLogins() {
2952 for (AutoLogin autoLogin : _autoLogins) {
2953 AutoLoginFilter.unregisterAutoLogin(autoLogin);
2954 }
2955 }
2956
2957 private List<AutoLogin> _autoLogins = new ArrayList<AutoLogin>();
2958
2959 }
2960
2961 private class CustomJspBag {
2962
2963 public CustomJspBag(
2964 String customJspDir, boolean customJspGlobal,
2965 List<String> customJsps) {
2966
2967 _customJspDir = customJspDir;
2968 _customJspGlobal = customJspGlobal;
2969 _customJsps = customJsps;
2970 }
2971
2972 public String getCustomJspDir() {
2973 return _customJspDir;
2974 }
2975
2976 public List<String> getCustomJsps() {
2977 return _customJsps;
2978 }
2979
2980 public boolean isCustomJspGlobal() {
2981 return _customJspGlobal;
2982 }
2983
2984 private String _customJspDir;
2985 private boolean _customJspGlobal;
2986 private List<String> _customJsps;
2987
2988 }
2989
2990 private class DLFileEntryProcessorContainer {
2991
2992 public void registerDLProcessor(DLProcessor dlProcessor) {
2993 DLProcessorRegistryUtil.register(dlProcessor);
2994
2995 _dlProcessors.add(dlProcessor);
2996 }
2997
2998 public void unregisterDLProcessors() {
2999 for (DLProcessor dlProcessor : _dlProcessors) {
3000 DLProcessorRegistryUtil.unregister(dlProcessor);
3001 }
3002
3003 _dlProcessors.clear();
3004 }
3005
3006 private List<DLProcessor> _dlProcessors = new ArrayList<DLProcessor>();
3007
3008 }
3009
3010 private class DLRepositoryContainer {
3011
3012 public void registerRepositoryFactory(
3013 String className, RepositoryFactory repositoryFactory) {
3014
3015 RepositoryFactoryUtil.registerRepositoryFactory(
3016 className, repositoryFactory);
3017
3018 _classNames.add(className);
3019 }
3020
3021 public void unregisterRepositoryFactories() {
3022 for (String className : _classNames) {
3023 RepositoryFactoryUtil.unregisterRepositoryFactory(className);
3024 }
3025
3026 _classNames.clear();
3027 }
3028
3029 private List<String> _classNames = new ArrayList<String>();
3030
3031 }
3032
3033 private class EventsContainer {
3034
3035 public void registerEvent(String eventName, Object event) {
3036 List<Object> events = _eventsMap.get(eventName);
3037
3038 if (events == null) {
3039 events = new ArrayList<Object>();
3040
3041 _eventsMap.put(eventName, events);
3042 }
3043
3044 events.add(event);
3045 }
3046
3047 public void unregisterEvents() {
3048 for (Map.Entry<String, List<Object>> entry :
3049 _eventsMap.entrySet()) {
3050
3051 String eventName = entry.getKey();
3052 List<Object> events = entry.getValue();
3053
3054 for (Object event : events) {
3055 EventsProcessorUtil.unregisterEvent(eventName, event);
3056 }
3057 }
3058 }
3059
3060 private Map<String, List<Object>> _eventsMap =
3061 new HashMap<String, List<Object>>();
3062
3063 }
3064
3065 private class HotDeployListenersContainer {
3066
3067 public void registerHotDeployListener(
3068 HotDeployListener hotDeployListener) {
3069
3070 HotDeployUtil.registerListener(hotDeployListener);
3071
3072 _hotDeployListeners.add(hotDeployListener);
3073 }
3074
3075 public void unregisterHotDeployListeners() {
3076 for (HotDeployListener hotDeployListener : _hotDeployListeners) {
3077 HotDeployUtil.unregisterListener(hotDeployListener);
3078 }
3079 }
3080
3081 private List<HotDeployListener> _hotDeployListeners =
3082 new ArrayList<HotDeployListener>();
3083
3084 }
3085
3086 private class IndexerPostProcessorContainer {
3087
3088 public void registerIndexerPostProcessor(
3089 String indexerClassName,
3090 IndexerPostProcessor indexerPostProcessor) {
3091
3092 List<IndexerPostProcessor> indexerPostProcessors =
3093 _indexerPostProcessors.get(indexerClassName);
3094
3095 if (indexerPostProcessors == null) {
3096 indexerPostProcessors = new ArrayList<IndexerPostProcessor>();
3097
3098 _indexerPostProcessors.put(
3099 indexerClassName, indexerPostProcessors);
3100 }
3101
3102 indexerPostProcessors.add(indexerPostProcessor);
3103 }
3104
3105 public void unregisterIndexerPostProcessor() {
3106 for (Map.Entry<String, List<IndexerPostProcessor>> entry :
3107 _indexerPostProcessors.entrySet()) {
3108
3109 String indexerClassName = entry.getKey();
3110 List<IndexerPostProcessor> indexerPostProcessors =
3111 entry.getValue();
3112
3113 Indexer indexer = IndexerRegistryUtil.getIndexer(
3114 indexerClassName);
3115
3116 for (IndexerPostProcessor indexerPostProcessor :
3117 indexerPostProcessors) {
3118
3119 indexer.unregisterIndexerPostProcessor(
3120 indexerPostProcessor);
3121 }
3122 }
3123 }
3124
3125 private Map<String, List<IndexerPostProcessor>> _indexerPostProcessors =
3126 new HashMap<String, List<IndexerPostProcessor>>();
3127
3128 }
3129
3130 private class LanguagesContainer {
3131
3132 public void addLanguage(
3133 Locale locale, Map<String, String> languageMap) {
3134
3135 Map<String, String> oldLanguageMap =
3136 LanguageResources.putLanguageMap(locale, languageMap);
3137
3138 _languagesMap.put(locale, oldLanguageMap);
3139 }
3140
3141 public void unregisterLanguages() {
3142 for (Map.Entry<Locale, Map<String, String>> entry :
3143 _languagesMap.entrySet()) {
3144
3145 Locale locale = entry.getKey();
3146 Map<String, String> languageMap = entry.getValue();
3147
3148 LanguageResources.putLanguageMap(locale, languageMap);
3149 }
3150 }
3151
3152 private Map<Locale, Map<String, String>> _languagesMap =
3153 new HashMap<Locale, Map<String, String>>();
3154
3155 }
3156
3157 private class LockListenerContainer {
3158
3159 public void registerLockListener(LockListener lockListener) {
3160 LockListenerRegistryUtil.register(lockListener);
3161
3162 _lockListeners.add(lockListener);
3163 }
3164
3165 public void unregisterLockListeners() {
3166 for (LockListener lockListener : _lockListeners) {
3167 LockListenerRegistryUtil.unregister(lockListener);
3168 }
3169
3170 _lockListeners.clear();
3171 }
3172
3173 private List<LockListener> _lockListeners =
3174 new ArrayList<LockListener>();
3175
3176 }
3177
3178 private class MergeStringArraysContainer implements StringArraysContainer {
3179
3180 private MergeStringArraysContainer(String key) {
3181 _portalStringArray = PropsUtil.getArray(key);
3182 }
3183
3184 @Override
3185 public String[] getStringArray() {
3186 List<String> mergedStringList = new UniqueList<String>();
3187
3188 mergedStringList.addAll(ListUtil.fromArray(_portalStringArray));
3189
3190 for (Map.Entry<String, String[]> entry :
3191 _pluginStringArrayMap.entrySet()) {
3192
3193 String[] pluginStringArray = entry.getValue();
3194
3195 mergedStringList.addAll(ListUtil.fromArray(pluginStringArray));
3196 }
3197
3198 return mergedStringList.toArray(
3199 new String[mergedStringList.size()]);
3200 }
3201
3202 @Override
3203 public void setPluginStringArray(
3204 String servletContextName, String[] pluginStringArray) {
3205
3206 if (pluginStringArray != null) {
3207 _pluginStringArrayMap.put(
3208 servletContextName, pluginStringArray);
3209 }
3210 else {
3211 _pluginStringArrayMap.remove(servletContextName);
3212 }
3213 }
3214
3215 private String[] _portalStringArray;
3216 private Map<String, String[]> _pluginStringArrayMap =
3217 new HashMap<String, String[]>();
3218
3219 }
3220
3221 private class ModelListenersContainer {
3222
3223 public void registerModelListener(
3224 String modelName, ModelListener<BaseModel<?>> modelListener) {
3225
3226 List<ModelListener<BaseModel<?>>> modelListeners =
3227 _modelListenersMap.get(modelName);
3228
3229 if (modelListeners == null) {
3230 modelListeners = new ArrayList<ModelListener<BaseModel<?>>>();
3231
3232 _modelListenersMap.put(modelName, modelListeners);
3233 }
3234
3235 modelListeners.add(modelListener);
3236 }
3237
3238 @SuppressWarnings("rawtypes")
3239 public void unregisterModelListeners() {
3240 for (Map.Entry<String, List<ModelListener<BaseModel<?>>>> entry :
3241 _modelListenersMap.entrySet()) {
3242
3243 String modelName = entry.getKey();
3244 List<ModelListener<BaseModel<?>>> modelListeners =
3245 entry.getValue();
3246
3247 BasePersistence persistence = getPersistence(modelName);
3248
3249 for (ModelListener<BaseModel<?>> modelListener :
3250 modelListeners) {
3251
3252 persistence.unregisterListener(modelListener);
3253 }
3254 }
3255 }
3256
3257 private Map<String, List<ModelListener<BaseModel<?>>>>
3258 _modelListenersMap =
3259 new HashMap<String, List<ModelListener<BaseModel<?>>>>();
3260
3261 }
3262
3263 private class OverrideStringArraysContainer
3264 implements StringArraysContainer {
3265
3266 private OverrideStringArraysContainer(String key) {
3267 _portalStringArray = PropsUtil.getArray(key);
3268 }
3269
3270 @Override
3271 public String[] getStringArray() {
3272 if (_pluginStringArray != null) {
3273 return _pluginStringArray;
3274 }
3275
3276 return _portalStringArray;
3277 }
3278
3279 public boolean isOverridden() {
3280 if (Validator.isNotNull(_servletContextName)) {
3281 return true;
3282 }
3283 else {
3284 return false;
3285 }
3286 }
3287
3288 @Override
3289 public void setPluginStringArray(
3290 String servletContextName, String[] pluginStringArray) {
3291
3292 if (pluginStringArray != null) {
3293 if (!isOverridden()) {
3294 _servletContextName = servletContextName;
3295 _pluginStringArray = pluginStringArray;
3296 }
3297 }
3298 else {
3299 if (_servletContextName.equals(servletContextName)) {
3300 _servletContextName = null;
3301 _pluginStringArray = null;
3302 }
3303 }
3304 }
3305
3306 private String[] _pluginStringArray;
3307 private String[] _portalStringArray;
3308 private String _servletContextName;
3309
3310 }
3311
3312 private class SanitizerContainer {
3313
3314 public void registerSanitizer(Sanitizer sanitizer) {
3315 _sanitizers.add(sanitizer);
3316
3317 SanitizerImpl sanitizerImpl =
3318 (SanitizerImpl)SanitizerUtil.getSanitizer();
3319
3320 sanitizerImpl.registerSanitizer(sanitizer);
3321 }
3322
3323 public void unregisterSanitizers() {
3324 SanitizerImpl sanitizerImpl =
3325 (SanitizerImpl)SanitizerUtil.getSanitizer();
3326
3327 for (Sanitizer sanitizer : _sanitizers) {
3328 sanitizerImpl.unregisterSanitizer(sanitizer);
3329 }
3330 }
3331
3332 private List<Sanitizer> _sanitizers = new ArrayList<Sanitizer>();
3333
3334 }
3335
3336 private class ServiceBag {
3337
3338 public ServiceBag(Object originalService) {
3339 _originalService = originalService;
3340 }
3341
3342 public void addCustomServiceConstructor(
3343 String servletContextName, ClassLoader portletClassLoader,
3344 Class<?> serviceTypeClass, Constructor<?> serviceImplConstructor) {
3345
3346 List<ServiceConstructor> serviceConstructors =
3347 _serviceConstructors.get(servletContextName);
3348
3349 if (serviceConstructors == null) {
3350 serviceConstructors = new ArrayList<ServiceConstructor>();
3351
3352 _serviceConstructors.put(
3353 servletContextName, serviceConstructors);
3354 }
3355
3356 ServiceConstructor serviceConstructor = new ServiceConstructor(
3357 portletClassLoader, serviceTypeClass, serviceImplConstructor);
3358
3359 serviceConstructors.add(serviceConstructor);
3360 }
3361
3362 public Object getCustomService() throws Exception {
3363 List<ServiceConstructor> serviceConstructors =
3364 new ArrayList<ServiceConstructor>();
3365
3366 for (Map.Entry<String, List<ServiceConstructor>> entry :
3367 _serviceConstructors.entrySet()) {
3368
3369 serviceConstructors.addAll(entry.getValue());
3370 }
3371
3372 Object customService = _originalService;
3373
3374 for (ServiceConstructor serviceConstructor : serviceConstructors) {
3375 ClassLoader portletClassLoader =
3376 serviceConstructor._portletClassLoader;
3377 Class<?> serviceTypeClass =
3378 serviceConstructor._serviceTypeClass;
3379 Constructor<?> serviceImplConstructor =
3380 serviceConstructor._serviceImplConstructor;
3381
3382 customService = serviceImplConstructor.newInstance(
3383 customService);
3384
3385 customService = ProxyUtil.newProxyInstance(
3386 portletClassLoader, new Class<?>[] {serviceTypeClass},
3387 new ClassLoaderBeanHandler(
3388 customService, portletClassLoader));
3389 }
3390
3391 return customService;
3392 }
3393
3394 private Object _originalService;
3395 private Map<String, List<ServiceConstructor>> _serviceConstructors =
3396 new HashMap<String, List<ServiceConstructor>>();
3397
3398 }
3399
3400 private class ServiceConstructor {
3401
3402 public ServiceConstructor(
3403 ClassLoader portletClassLoader, Class<?> serviceTypeClass,
3404 Constructor<?> serviceImplConstructor) {
3405
3406 _portletClassLoader = portletClassLoader;
3407 _serviceTypeClass = serviceTypeClass;
3408 _serviceImplConstructor = serviceImplConstructor;
3409 }
3410
3411 private ClassLoader _portletClassLoader;
3412 private Constructor<?> _serviceImplConstructor;
3413 private Class<?> _serviceTypeClass;
3414
3415 }
3416
3417 private class ServicesContainer {
3418
3419 public void addServiceBag(
3420 String servletContextName, ClassLoader portletClassLoader,
3421 String serviceType, Class<?> serviceTypeClass,
3422 Constructor<?> serviceImplConstructor, Object wrappedService) {
3423
3424 ServiceBag serviceBag = _serviceBags.get(serviceType);
3425
3426 if (serviceBag == null) {
3427 serviceBag = new ServiceBag(wrappedService);
3428
3429 _serviceBags.put(serviceType, serviceBag);
3430 }
3431
3432 serviceBag.addCustomServiceConstructor(
3433 servletContextName, portletClassLoader, serviceTypeClass,
3434 serviceImplConstructor);
3435 }
3436
3437 private Map<String, ServiceBag> _serviceBags =
3438 new HashMap<String, ServiceBag>();
3439
3440 }
3441
3442 private class ServletFiltersContainer {
3443
3444 public InvokerFilterHelper getInvokerFilterHelper() {
3445 ServletContext portalServletContext = ServletContextPool.get(
3446 PortalUtil.getPathContext());
3447
3448 InvokerFilterHelper invokerFilterHelper =
3449 (InvokerFilterHelper)portalServletContext.getAttribute(
3450 InvokerFilterHelper.class.getName());
3451
3452 return invokerFilterHelper;
3453 }
3454
3455 public void registerFilter(
3456 String filterName, Filter filter, FilterConfig filterConfig) {
3457
3458 InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3459
3460 Filter previousFilter = invokerFilterHelper.registerFilter(
3461 filterName, filter);
3462
3463 _filterConfigs.put(filterName, filterConfig);
3464 _filters.put(filterName, previousFilter);
3465 }
3466
3467 public void registerFilterMapping(
3468 String filterName, List<String> urlPatterns,
3469 List<String> dispatchers, String positionFilterName,
3470 boolean after) {
3471
3472 InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3473
3474 Filter filter = invokerFilterHelper.getFilter(filterName);
3475
3476 FilterConfig filterConfig = _filterConfigs.get(filterName);
3477
3478 if (filterConfig == null) {
3479 filterConfig = invokerFilterHelper.getFilterConfig(filterName);
3480 }
3481
3482 if (filter == null) {
3483 if (_log.isWarnEnabled()) {
3484 _log.warn(
3485 "No filter exists with filter mapping " + filterName);
3486 }
3487
3488 return;
3489 }
3490
3491 FilterMapping filterMapping = new FilterMapping(
3492 filter, filterConfig, urlPatterns, dispatchers);
3493
3494 invokerFilterHelper.registerFilterMapping(
3495 filterMapping, positionFilterName, after);
3496 }
3497
3498 public void unregisterFilterMappings() {
3499 InvokerFilterHelper invokerFilterHelper = getInvokerFilterHelper();
3500
3501 for (String filterName : _filters.keySet()) {
3502 Filter filter = _filters.get(filterName);
3503
3504 Filter previousFilter = invokerFilterHelper.registerFilter(
3505 filterName, filter);
3506
3507 previousFilter.destroy();
3508 }
3509
3510 for (FilterMapping filterMapping : _filterMappings) {
3511 invokerFilterHelper.unregisterFilterMapping(filterMapping);
3512
3513 filterMapping.setFilter(null);
3514 }
3515 }
3516
3517 private Map<String, FilterConfig> _filterConfigs =
3518 new HashMap<String, FilterConfig>();
3519 private List<FilterMapping> _filterMappings =
3520 new ArrayList<FilterMapping>();
3521 private Map<String, Filter> _filters = new HashMap<String, Filter>();
3522
3523 }
3524
3525 private interface StringArraysContainer {
3526
3527 public String[] getStringArray();
3528
3529 public void setPluginStringArray(
3530 String servletContextName, String[] pluginStringArray);
3531
3532 }
3533
3534 private class StrutsActionsContainer {
3535
3536 public void registerStrutsAction(String path, Object strutsAction) {
3537 if (strutsAction instanceof StrutsAction) {
3538 StrutsActionRegistryUtil.register(
3539 path, (StrutsAction)strutsAction);
3540 }
3541 else {
3542 StrutsActionRegistryUtil.register(
3543 path, (StrutsPortletAction)strutsAction);
3544 }
3545
3546 _paths.add(path);
3547 }
3548
3549 public void unregisterStrutsActions() {
3550 for (String path : _paths) {
3551 StrutsActionRegistryUtil.unregister(path);
3552 }
3553
3554 _paths.clear();
3555 }
3556
3557 private List<String> _paths = new ArrayList<String>();
3558
3559 }
3560
3561 }