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