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