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