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