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