KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > caucho > ejb > burlap > BurlapProtocol


1 /*
2  * Copyright (c) 1998-2006 Caucho Technology -- all rights reserved
3  *
4  * This file is part of Resin(R) Open Source
5  *
6  * Each copy or derived work must preserve the copyright notice and this
7  * notice unmodified.
8  *
9  * Resin Open Source is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * Resin Open Source is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
17  * of NON-INFRINGEMENT. See the GNU General Public License for more
18  * details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with Resin Open Source; if not, write to the
22  * Free SoftwareFoundation, Inc.
23  * 59 Temple Place, Suite 330
24  * Boston, MA 02111-1307 USA
25  *
26  * @author Scott Ferguson
27  */
28
29 package com.caucho.ejb.burlap;
30
31 import com.caucho.config.ConfigException;
32 import com.caucho.ejb.AbstractServer;
33 import com.caucho.ejb.message.MessageServer;
34 import com.caucho.ejb.protocol.HandleEncoder;
35 import com.caucho.ejb.protocol.ProtocolContainer;
36 import com.caucho.ejb.protocol.Skeleton;
37 import com.caucho.hessian.io.HessianRemoteResolver;
38 import com.caucho.util.L10N;
39 import com.caucho.util.Log;
40
41 import javax.ejb.EJBHome JavaDoc;
42 import javax.ejb.EJBObject JavaDoc;
43 import java.util.ArrayList JavaDoc;
44 import java.util.HashMap JavaDoc;
45 import java.util.logging.Logger JavaDoc;
46 /**
47  * Server containing all the EJBs for a given configuration.
48  *
49  * <p>Each protocol will extend the container to override Handle creation.
50  */
51 public class BurlapProtocol extends ProtocolContainer {
52   private static final L10N L = new L10N(BurlapProtocol.class);
53   private static final Logger JavaDoc log = Log.open(BurlapProtocol.class);
54
55   private Class JavaDoc _objectSkelClass;
56   private Class JavaDoc _homeSkelClass;
57
58   private HashMap JavaDoc<AbstractServer,Class JavaDoc> _homeSkeletonMap =
59     new HashMap JavaDoc<AbstractServer,Class JavaDoc>();
60
61   private HashMap JavaDoc<AbstractServer,Class JavaDoc> _objectSkeletonMap =
62     new HashMap JavaDoc<AbstractServer,Class JavaDoc>();
63
64   private HashMap JavaDoc<String JavaDoc,AbstractServer> _serverMap =
65     new HashMap JavaDoc<String JavaDoc,AbstractServer>();
66
67   private HessianRemoteResolver _resolver;
68
69   /**
70    * Create a server with the given prefix name.
71    */
72   public BurlapProtocol()
73   {
74     _resolver = new BurlapStubFactory();
75   }
76
77   public String JavaDoc getName()
78   {
79     return "burlap";
80   }
81
82   /**
83    * Adds a server to the protocol.
84    */
85   public void addServer(AbstractServer server)
86   {
87     log.finer("Burlap[" + server + "] added");
88
89     _serverMap.put(server.getProtocolId(), server);
90   }
91
92   /**
93    * Removes a server from the protocol.
94    */
95   public void removeServer(AbstractServer server)
96   {
97     _serverMap.remove(server.getProtocolId());
98   }
99
100   protected HandleEncoder createHandleEncoder(AbstractServer server,
101                                               Class JavaDoc primaryKeyClass)
102     throws ConfigException
103   {
104     return new BurlapHandleEncoder(server,
105                                    getURLPrefix() + server.getProtocolId(),
106                                    primaryKeyClass);
107   }
108
109   /**
110    * Returns the skeleton
111    */
112   public Skeleton getSkeleton(String JavaDoc uri, String JavaDoc queryString)
113     throws Exception JavaDoc
114   {
115     String JavaDoc serverId = uri;
116     String JavaDoc objectId = null;
117
118     // decode ?id=my-instance-id
119 if (queryString != null) {
120       int p = queryString.indexOf('=');
121
122       if (p >= 0)
123     objectId = queryString.substring(p + 1);
124       else
125     objectId = queryString;
126     }
127
128     AbstractServer server = getProtocolManager().getServerByEJBName(serverId);
129
130     if (server == null) {
131       ArrayList JavaDoc children = getProtocolManager().getRemoteChildren(serverId);
132
133       if (children != null && children.size() > 0)
134         return new NameContextSkeleton(this, serverId);
135       else
136         return null; // XXX: should return error skeleton
137 /*
138     ArrayList children = getServerContainer().getRemoteChildren(serverId);
139
140     if (children != null && children.size() > 0)
141     return new NameContextSkeleton(this, serverId);
142     else
143     return null; // XXX: should return error skeleton
144       */
145     }
146     else if (objectId != null) {
147       Object JavaDoc key = server.getHandleEncoder("burlap").objectIdToKey(objectId);
148
149       EJBObject JavaDoc obj = server.getContext(key, false).getRemoteView();
150
151       Class JavaDoc objectSkelClass = getObjectSkelClass(server);
152
153       BurlapSkeleton skel = (BurlapSkeleton) objectSkelClass.newInstance();
154       skel._setServer(server);
155       skel._setResolver(_resolver);
156       skel._setObject(obj);
157       return skel;
158     }
159     else if (server instanceof MessageServer) {
160       return new MessageSkeleton((MessageServer) server);
161     }
162     else {
163       Object JavaDoc remote = server.getRemoteObject();
164
165       if (remote instanceof EJBHome JavaDoc) {
166     Class JavaDoc homeSkelClass = getHomeSkelClass(server);
167
168     BurlapSkeleton skel = (BurlapSkeleton) homeSkelClass.newInstance();
169     skel._setServer(server);
170     skel._setResolver(_resolver);
171     skel._setObject(remote);
172
173     return skel;
174       }
175       else if (remote instanceof EJBObject JavaDoc) {
176     Class JavaDoc skelClass = getObjectSkelClass(server);
177
178     BurlapSkeleton skel = (BurlapSkeleton) skelClass.newInstance();
179     skel._setServer(server);
180     skel._setResolver(_resolver);
181     skel._setObject(remote);
182
183     return skel;
184       }
185     }
186
187     return null;
188   }
189
190   /**
191    * Returns the skeleton
192    */
193   public Skeleton getExceptionSkeleton()
194     throws Exception JavaDoc
195   {
196     return new ExceptionSkeleton();
197   }
198
199   /**
200    * Returns the class for home skeletons.
201    */
202   protected Class JavaDoc getHomeSkelClass(AbstractServer server)
203     throws Exception JavaDoc
204   {
205     Class JavaDoc homeSkelClass = (Class JavaDoc) _homeSkeletonMap.get(server);
206     
207     if (homeSkelClass != null)
208       return homeSkelClass;
209     
210     Class JavaDoc remoteHomeClass = server.getRemoteHomeClass();
211
212     homeSkelClass = BurlapSkeletonGenerator.generate(remoteHomeClass,
213                                                         getWorkPath());
214
215     _homeSkeletonMap.put(server, homeSkelClass);
216
217     return homeSkelClass;
218   }
219
220   /**
221    * Returns the class for home skeletons.
222    */
223   protected Class JavaDoc getObjectSkelClass(AbstractServer server)
224     throws Exception JavaDoc
225   {
226     Class JavaDoc objectSkelClass = (Class JavaDoc) _objectSkeletonMap.get(server);
227     
228     if (objectSkelClass != null)
229       return objectSkelClass;
230     
231     Class JavaDoc remoteObjectClass = server.getRemoteObjectClass();
232
233     objectSkelClass = BurlapSkeletonGenerator.generate(remoteObjectClass,
234                                                         getWorkPath());
235
236     _objectSkeletonMap.put(server, objectSkelClass);
237
238     return objectSkelClass;
239   }
240 }
241
Popular Tags