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