001: /* $Id: IPCHelper.java,v 1.3 2005/08/12 12:30:00 vs152012 Exp $
002: * Copyright 2004-2005 Sun Microsystems, Inc. All rights reserved.
003: * Use is subject to license terms.
004: */
005: package com.sun.portal.container.portlet.impl;
006:
007: import com.sun.portal.desktop.ServletContextThreadLocalizer;
008: import com.sun.portal.providers.util.ProviderProperties;
009: import com.sun.portal.providers.context.ProviderContext;
010: import com.sun.portal.portletcontainercommon.PortletContainerConstants;
011:
012: import javax.servlet.ServletContext;
013: import java.util.ArrayList;
014: import java.util.LinkedHashMap;
015: import java.util.Set;
016: import java.util.TreeSet;
017: import java.util.regex.Pattern;
018: import java.util.Iterator;
019: import java.util.Map;
020: import java.util.HashMap;
021: import java.util.StringTokenizer;
022: import java.net.URLEncoder;
023: import java.net.URLDecoder;
024:
025: public class IPCHelper {
026: private static final String DELIMITER = "|";
027: private static final String PARAM_DELIMITER = "|";
028: private static final String KEY_DELIMITER = "=";
029: private static final String ARRAY_DELIMITER = ";";
030:
031: public LinkedHashMap getEventPortletMap(ProviderContext pc) {
032: Set entityIDs = (Set) pc
033: .getSessionProperty(PortletContainerConstants.TAB_PORTLET_LIST);
034: Set evtSet = createEventSet(entityIDs);
035: return setPortletEventMap(evtSet, entityIDs);
036: }
037:
038: private Set createEventSet(Set entityIDs) {
039: ServletContext sc = ServletContextThreadLocalizer.get();
040: TreeSet evtSet = new TreeSet();
041: Iterator iter = entityIDs.iterator();
042: while (iter.hasNext()) {
043: String entityID = (String) iter.next();
044: String appName = getAppNameFromEntityID(entityID);
045: ServletContext context = sc.getContext(appName);
046: LinkedHashMap evtGeneratedMap = (LinkedHashMap) context
047: .getAttribute(ProviderProperties.GENERATE_EVENT_LIST);
048: if (evtGeneratedMap != null && evtGeneratedMap.size() > 0) {
049: Set tmpSet = evtGeneratedMap.keySet();
050: if (tmpSet != null && tmpSet.size() > 0) {
051: Iterator iterPort = tmpSet.iterator();
052: while (iterPort.hasNext()) {
053: String portlet = (String) iterPort.next();
054: //Find the list of the events for this portlet and add it to
055: //the event set
056: ArrayList events = (ArrayList) evtGeneratedMap
057: .get(portlet);
058: for (int i = 0; i < events.size(); i++) {
059: evtSet.add(events.get(i));
060: }
061: }
062: }
063: }
064: }
065: return evtSet;
066: }
067:
068: private LinkedHashMap setPortletEventMap(Set evtSet, Set entityIDs) {
069: ServletContext sc = ServletContextThreadLocalizer.get();
070: Iterator iter = entityIDs.iterator();
071:
072: LinkedHashMap evtMap = new LinkedHashMap();
073: while (iter.hasNext()) {
074: String entityID = (String) iter.next();
075: String appName = getAppNameFromEntityID(entityID);
076: String portletName = getPortletNameFromEntityID(entityID);
077: ServletContext context = sc.getContext(appName);
078: LinkedHashMap evtConsumedMap = (LinkedHashMap) context
079: .getAttribute(ProviderProperties.CONSUME_EVENT_LIST);
080: if (evtConsumedMap != null && evtConsumedMap.size() > 0) {
081: ArrayList events = (ArrayList) evtConsumedMap
082: .get(portletName);
083: if (events != null && events.size() > 0) {
084: Iterator iterEvents = events.iterator();
085: while (iterEvents.hasNext()) {
086: String evtName = (String) iterEvents.next();
087: if (evtName.equals("*")) {
088: //Put this portlet name for all events ...
089: subscribeAll(entityID, evtMap, evtSet);
090: break;
091: } else if (evtSet.contains(evtName)) {
092: //Put the evt-portlet pair in the evtMap
093: subscribe(entityID, evtMap, evtName);
094: } else {
095: regExpMatch(evtName, evtMap, evtSet,
096: entityID);
097: }
098: }
099: }
100: }
101: }
102: return evtMap;
103: }
104:
105: private void regExpMatch(String eventName, LinkedHashMap evtMap,
106: Set evtSet, String portletName) {
107: Iterator events = evtSet.iterator();
108: while (events.hasNext()) {
109: String event = (String) events.next();
110: if (Pattern.matches(eventName, event)) {
111: subscribe(portletName, evtMap, event);
112: }
113: }
114: }
115:
116: private void subscribeAll(String portletName, LinkedHashMap evtMap,
117: Set evtSet) {
118: Iterator iter = evtSet.iterator();
119: while (iter.hasNext()) {
120: String eventName = (String) iter.next();
121: subscribe(portletName, evtMap, eventName);
122: }
123: }
124:
125: private void subscribe(String portletName, LinkedHashMap evtMap,
126: String eventName) {
127: Set keySet = evtMap.keySet();
128: if (keySet.contains(eventName)) {
129: Set portlets = (Set) evtMap.get(eventName);
130: portlets.add(portletName);
131: evtMap.put(eventName, portlets);
132: } else {
133: Set portlets = new TreeSet();
134: portlets.add(portletName);
135: evtMap.put(eventName, portlets);
136: }
137: }
138:
139: private String getPortletNameFromEntityID(String entityID) {
140: String realEntityID = stripInstanceKey(entityID);
141: return entityID.substring(realEntityID.indexOf(DELIMITER) + 1,
142: realEntityID.lastIndexOf(DELIMITER));
143: }
144:
145: private String getAppNameFromEntityID(String entityID) {
146: String realEntityID = stripInstanceKey(entityID);
147: return "/"
148: + realEntityID.substring(0, realEntityID
149: .indexOf(DELIMITER));
150: }
151:
152: private String stripInstanceKey(String entityID) {
153: int numDelimiter = 0;
154: int startIndex = 0;
155:
156: // count the number of delimiter in the entity ID
157: while ((startIndex = entityID
158: .indexOf(DELIMITER, startIndex + 1)) != -1) {
159: numDelimiter++;
160: }
161:
162: if (numDelimiter > 2) {
163: return entityID.substring(0, entityID
164: .lastIndexOf(DELIMITER));
165: } else {
166: return entityID;
167: }
168: }
169:
170: /**
171: * Convert a Map to String representation.
172: */
173: public static String getStringFromMap(Map paramMap) {
174: String paramString = "";
175: StringBuffer sb = new StringBuffer();
176: for (Iterator i = paramMap.keySet().iterator(); i.hasNext();) {
177: String key = (String) i.next();
178: sb.append(key).append(KEY_DELIMITER);
179: try {
180: String[] value = (String[]) paramMap.get(key);
181: for (int j = 0; j < value.length; j++) {
182: sb.append(URLEncoder.encode(value[j]));
183: if ((j + 1) < value.length) {
184: sb.append(ARRAY_DELIMITER);
185: }
186: }
187: } catch (ClassCastException cce) {
188: //getProviderContext().debugWarning("Util.getStringFromMap(): RenderParam value should be a String array", cce);
189: }
190: if (i.hasNext()) {
191: sb.append(PARAM_DELIMITER);
192: }
193: }
194: paramString = sb.toString();
195:
196: return paramString;
197: }
198:
199: /**
200: * Convert a String to Map representation
201: */
202: public static Map getMapFromString(String paramString) {
203: Map paramMap = new HashMap();
204: StringTokenizer paramtokenizer = new StringTokenizer(
205: paramString, PARAM_DELIMITER);
206: while (paramtokenizer.hasMoreTokens()) {
207: String keyValue = paramtokenizer.nextToken();
208: StringTokenizer keyTokenizer = new StringTokenizer(
209: keyValue, KEY_DELIMITER);
210: if (keyTokenizer.countTokens() == 2) {
211: String key = keyTokenizer.nextToken();
212: String value = keyTokenizer.nextToken();
213: //if (value.indexOf(ARRAY_DELIMITER) != -1) {
214: StringTokenizer valueTokenizer = new StringTokenizer(
215: value, ARRAY_DELIMITER);
216: int noTokens = valueTokenizer.countTokens();
217: String[] valueArray = new String[noTokens];
218: for (int i = 0; i < noTokens; i++) {
219: valueArray[i] = URLDecoder.decode(valueTokenizer
220: .nextToken());
221: }
222: paramMap.put(key, valueArray);
223: }
224: }
225: return paramMap;
226: }
227: }
|