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