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