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