|
1
18 package org.apache.activemq.broker.jmx;
19
20 import java.io.IOException  ;
21 import java.util.ArrayList ;
22 import java.util.Date ;
23 import java.util.HashMap ;
24 import java.util.Map ;
25
26 import javax.jms.DeliveryMode ;
27 import javax.jms.JMSException ;
28 import javax.management.openmbean.ArrayType ;
29 import javax.management.openmbean.CompositeData ;
30 import javax.management.openmbean.CompositeDataSupport ;
31 import javax.management.openmbean.CompositeType ;
32 import javax.management.openmbean.OpenDataException ;
33 import javax.management.openmbean.OpenType ;
34 import javax.management.openmbean.SimpleType ;
35
36 import org.apache.activemq.command.ActiveMQBytesMessage;
37 import org.apache.activemq.command.ActiveMQMapMessage;
38 import org.apache.activemq.command.ActiveMQMessage;
39 import org.apache.activemq.command.ActiveMQObjectMessage;
40 import org.apache.activemq.command.ActiveMQStreamMessage;
41 import org.apache.activemq.command.ActiveMQTextMessage;
42 import org.apache.activemq.command.Message;
43
44 public class OpenTypeSupport {
45
46 interface OpenTypeFactory {
47 CompositeType getCompositeType() throws OpenDataException ;
48 Map getFields( Object o ) throws OpenDataException ;
49 }
50
51 private static final HashMap openTypeFactories = new HashMap ();
52
53 abstract static class AbstractOpenTypeFactory implements OpenTypeFactory {
54
55 private CompositeType compositeType;
56 ArrayList itemNamesList = new ArrayList ();
57 ArrayList itemDescriptionsList = new ArrayList ();
58 ArrayList itemTypesList = new ArrayList ();
59
60 public CompositeType getCompositeType() throws OpenDataException {
61 if( compositeType == null ) {
62 init();
63 compositeType = createCompositeType();
64 }
65 return compositeType;
66 }
67
68 protected void init() throws OpenDataException {
69 }
70
71 protected CompositeType createCompositeType() throws OpenDataException {
72 String [] itemNames = (String []) itemNamesList.toArray(new String [itemNamesList.size()]);
73 String [] itemDescriptions = (String []) itemDescriptionsList.toArray(new String [itemDescriptionsList.size()]);
74 OpenType [] itemTypes = (OpenType []) itemTypesList.toArray(new OpenType [itemTypesList.size()]);
75 return new CompositeType (getTypeName(), getDescription(), itemNames, itemDescriptions, itemTypes);
76 }
77
78 abstract protected String getTypeName();
79
80 protected void addItem(String name, String description, OpenType type) {
81 itemNamesList.add(name);
82 itemDescriptionsList.add(description);
83 itemTypesList.add(type);
84 }
85
86
87 protected String getDescription() {
88 return getTypeName();
89 }
90
91 public Map getFields(Object o) throws OpenDataException {
92 HashMap rc = new HashMap ();
93 return rc;
94 }
95 }
96
97 static class MessageOpenTypeFactory extends AbstractOpenTypeFactory {
98
99 protected String getTypeName() {
100 return ActiveMQMessage.class.getName();
101 }
102
103 protected void init() throws OpenDataException {
104 super.init();
105 addItem("JMSCorrelationID", "JMSCorrelationID", SimpleType.STRING);
106 addItem("JMSDestination", "JMSDestination", SimpleType.STRING);
107 addItem("JMSMessageID", "JMSMessageID", SimpleType.STRING);
108 addItem("JMSReplyTo", "JMSReplyTo", SimpleType.STRING);
109 addItem("JMSType", "JMSType", SimpleType.STRING);
110 addItem("JMSDeliveryMode", "JMSDeliveryMode", SimpleType.STRING);
111 addItem("JMSExpiration", "JMSExpiration", SimpleType.LONG);
112 addItem("JMSPriority", "JMSPriority", SimpleType.INTEGER);
113 addItem("JMSRedelivered", "JMSRedelivered", SimpleType.BOOLEAN);
114 addItem("JMSTimestamp", "JMSTimestamp", SimpleType.DATE);
115 addItem("Properties", "Properties", SimpleType.STRING);
116 }
117
118 public Map getFields(Object o) throws OpenDataException {
119 ActiveMQMessage m = (ActiveMQMessage) o;
120 Map rc = super.getFields(o);
121 rc.put("JMSCorrelationID", m.getJMSCorrelationID());
122 rc.put("JMSDestination", ""+m.getJMSDestination());
123 rc.put("JMSMessageID", m.getJMSMessageID());
124 rc.put("JMSReplyTo", ""+m.getJMSReplyTo());
125 rc.put("JMSType", m.getJMSType());
126 rc.put("JMSDeliveryMode", m.getJMSDeliveryMode()==DeliveryMode.PERSISTENT ? "PERSISTENT" : "NON-PERSISTENT");
127 rc.put("JMSExpiration", new Long (m.getJMSExpiration()));
128 rc.put("JMSPriority", new Integer (m.getJMSPriority()));
129 rc.put("JMSRedelivered", new Boolean (m.getJMSRedelivered()));
130 rc.put("JMSTimestamp", new Date (m.getJMSTimestamp()));
131 try {
132 rc.put("Properties", ""+m.getProperties());
133 } catch (IOException e) {
134 rc.put("Properties", "");
135 }
136 return rc;
137 }
138 }
139
140 static class ByteMessageOpenTypeFactory extends MessageOpenTypeFactory {
141
142 protected String getTypeName() {
143 return ActiveMQBytesMessage.class.getName();
144 }
145
146 protected void init() throws OpenDataException {
147 super.init();
148 addItem("BodyLength", "Body length", SimpleType.LONG);
149 addItem("BodyPreview", "Body preview", new ArrayType (1,SimpleType.BYTE));
150 }
151
152 public Map getFields(Object o) throws OpenDataException {
153 ActiveMQBytesMessage m = (ActiveMQBytesMessage) o;
154 Map rc = super.getFields(o);
155 long length=0;
156 try {
157 length = m.getBodyLength();
158 rc.put("BodyLength", new Long (length));
159 } catch (JMSException e) {
160 rc.put("BodyLength", new Long (0));
161 }
162 try {
163 byte preview[] = new byte[ (int)Math.min(length, 255) ];
164 m.readBytes(preview);
165
166 Byte data[] = new Byte [ preview.length ];
169 for (int i = 0; i < data.length; i++) {
170 data[i] = new Byte (preview[i]);
171 }
172
173 rc.put("BodyPreview", data);
174 } catch (JMSException e) {
175 rc.put("BodyPreview", new byte[]{});
176 }
177 return rc;
178 }
179
180 }
181
182 static class MapMessageOpenTypeFactory extends MessageOpenTypeFactory {
183 protected String getTypeName() {
184 return ActiveMQMapMessage.class.getName();
185 }
186
187 protected void init() throws OpenDataException {
188 super.init();
189 addItem("ContentMap", "Content map", SimpleType.STRING);
190 }
191
192 public Map getFields(Object o) throws OpenDataException {
193 ActiveMQMapMessage m = (ActiveMQMapMessage) o;
194 Map rc = super.getFields(o);
195 long length=0;
196 try {
197 rc.put("ContentMap", ""+m.getContentMap());
198 } catch (JMSException e) {
199 rc.put("ContentMap", "");
200 }
201 return rc;
202 }
203 }
204
205 static class ObjectMessageOpenTypeFactory extends MessageOpenTypeFactory {
206 protected String getTypeName() {
207 return ActiveMQObjectMessage.class.getName();
208 }
209
210 protected void init() throws OpenDataException {
211 super.init();
212 }
213
214 public Map getFields(Object o) throws OpenDataException {
215 ActiveMQObjectMessage m = (ActiveMQObjectMessage) o;
216 Map rc = super.getFields(o);
217 return rc;
218 }
219 }
220
221 static class StreamMessageOpenTypeFactory extends MessageOpenTypeFactory {
222 protected String getTypeName() {
223 return ActiveMQStreamMessage.class.getName();
224 }
225
226 protected void init() throws OpenDataException {
227 super.init();
228 }
229
230 public Map getFields(Object o) throws OpenDataException {
231 ActiveMQStreamMessage m = (ActiveMQStreamMessage) o;
232 Map rc = super.getFields(o);
233 return rc;
234 }
235 }
236
237 static class TextMessageOpenTypeFactory extends MessageOpenTypeFactory {
238 protected String getTypeName() {
239 return ActiveMQTextMessage.class.getName();
240 }
241
242 protected void init() throws OpenDataException {
243 super.init();
244 addItem("Text", "Text", SimpleType.STRING);
245 }
246
247 public Map getFields(Object o) throws OpenDataException {
248 ActiveMQTextMessage m = (ActiveMQTextMessage) o;
249 Map rc = super.getFields(o);
250 try {
251 rc.put("Text", ""+m.getText());
252 } catch (JMSException e) {
253 rc.put("Text", "");
254 }
255 return rc;
256 }
257 }
258
259 static {
260 openTypeFactories.put(ActiveMQMessage.class, new MessageOpenTypeFactory());
261 openTypeFactories.put(ActiveMQBytesMessage.class, new ByteMessageOpenTypeFactory());
262 openTypeFactories.put(ActiveMQMapMessage.class, new MapMessageOpenTypeFactory());
263 openTypeFactories.put(ActiveMQObjectMessage.class, new ObjectMessageOpenTypeFactory());
264 openTypeFactories.put(ActiveMQStreamMessage.class, new StreamMessageOpenTypeFactory());
265 openTypeFactories.put(ActiveMQTextMessage.class, new TextMessageOpenTypeFactory());
266 }
267
268 public static OpenTypeFactory getFactory(Class clazz) throws OpenDataException {
269 return (OpenTypeFactory) openTypeFactories.get(clazz);
270 }
271
272 public static CompositeData convert(Message message) throws OpenDataException {
273 OpenTypeFactory f = getFactory(message.getClass());
274 if( f == null )
275 throw new OpenDataException ("Cannot create a CompositeData for type: "+message.getClass().getName());
276 CompositeType ct = f.getCompositeType();
277 Map fields = f.getFields(message);
278 return new CompositeDataSupport (ct, fields);
279 }
280
281
282 }
283 |
Popular Tags |
Java API By Example, From Geeks To Geeks.