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