Source code: org/jellyfish/implementation/DirectoryManagerDefault.java
1 package org.jellyfish.implementation;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Iterator;
6
7 import javax.jdo.Extent;
8 import javax.jdo.PersistenceManagerFactory;
9 import javax.jdo.Query;
10 import javax.jdo.Transaction;
11 import javax.naming.InvalidNameException;
12 import javax.naming.NameNotFoundException;
13 import javax.naming.NamingEnumeration;
14 import javax.naming.NamingException;
15 import javax.naming.directory.Attributes;
16 import javax.naming.directory.DirContext;
17 import javax.naming.directory.SearchResult;
18
19 import org.apache.avalon.framework.logger.LogEnabled;
20 import org.apache.avalon.framework.logger.Logger;
21 import org.apache.avalon.framework.service.ServiceException;
22 import org.apache.avalon.framework.service.ServiceManager;
23 import org.apache.avalon.framework.service.Serviceable;
24 import org.jellyfish.ConnectionManager;
25 import org.jellyfish.DirectoryManager;
26 import org.jellyfish.MappingManager;
27 import org.jellyfish.ObjectMapNotFoundException;
28
29 public class DirectoryManagerDefault
30 implements DirectoryManager, Serviceable, LogEnabled {
31 private static DirectoryManagerDefault instance;
32 private ServiceManager serviceManager;
33 private Logger logger;
34 private ConnectionManager connectionManager;
35 private MappingManager mappingManager;
36
37 public DirectoryManagerDefault() {
38 }
39
40 public void service(ServiceManager serviceManager)
41 throws ServiceException {
42 this.serviceManager = serviceManager;
43 try {
44 mappingManager =
45 (MappingManager) serviceManager.lookup(MappingManager.ROLE);
46 connectionManager =
47 (ConnectionManager) serviceManager.lookup(
48 ConnectionManager.ROLE);
49 } catch (ServiceException e) {
50 logger.fatalError(e.getMessage(), e);
51 throw new RuntimeException(e);
52 }
53 }
54
55 public void enableLogging(Logger logger) {
56 this.logger = logger;
57 }
58
59 public void store(Object object) {
60 DirContext dirContext = null;
61 String objectDn = null;
62 Attributes attributes = null;
63 try {
64 dirContext = connectionManager.getContext();
65 objectDn = mappingManager.getObjectDn(object);
66 attributes = mappingManager.mapToAttributes(object);
67 try {
68 dirContext.modifyAttributes(
69 objectDn,
70 DirContext.REPLACE_ATTRIBUTE,
71 attributes);
72 } catch (NameNotFoundException exception) {
73 createSubContext(dirContext, object, objectDn, attributes);
74 }
75 } catch (NamingException e) {
76 // LDAPd hack:
77 // look for NameNotFound here and createSubContext() if necessary
78 if (e.getMessage().indexOf("javax.naming.NameNotFoundException")
79 > 0) {
80 createSubContext(dirContext, object, objectDn, attributes);
81 } else {
82 logger.fatalError(e.toString());
83 }
84 }
85 }
86
87 private void createSubContext(
88 DirContext dirContext,
89 Object object,
90 String objectDn,
91 Attributes attributes) {
92 try {
93 attributes.put(
94 "objectclass",
95 mappingManager.getObjectMapping(object).getLdapName());
96 dirContext.createSubcontext(objectDn, attributes);
97 } catch (ObjectMapNotFoundException e) {
98 logger.fatalError(e.toString());
99 } catch (NamingException e) {
100 logger.fatalError(e.toString());
101 }
102 }
103
104 public Object lookup(Object object) {
105 try {
106 return mappingManager.mapFromAttributes(
107 connectionManager.getContext().getAttributes(
108 mappingManager.getObjectDn(object)));
109 } catch (NamingException e) {
110 logger.fatalError(e.toString());
111 }
112
113 return object;
114 }
115
116 public void delete(Object object) {
117 try {
118 connectionManager.getContext().destroySubcontext(
119 mappingManager.getObjectDn(object));
120 } catch (InvalidNameException exception) {
121 logger.debug("(This doesn't matter since it's for a delete): " + exception.getMessage());
122 } catch (NamingException e) {
123 logger.fatalError(e.toString());
124 }
125 }
126
127 public Collection search(Object object) {
128 Collection searchResults = new ArrayList();
129 try {
130 NamingEnumeration resultEnumeration =
131 connectionManager.getContext().search(
132 getParentDn(mappingManager.getObjectDn(object)),
133 mappingManager.mapToAttributes(object));
134 while (resultEnumeration.hasMore()) {
135 SearchResult searchResult =
136 (SearchResult) resultEnumeration.next();
137 searchResults.add(
138 mappingManager.mapFromAttributes(
139 searchResult.getAttributes()));
140 }
141 } catch (NamingException namingException) {
142 logger.fatalError(
143 "Exception while searching for ." + object,
144 namingException);
145 }
146 return searchResults;
147 }
148
149 private String getParentDn(String dn) {
150 if (dn != null && dn.trim().length() > 0) {
151 int firstComma = dn.indexOf(',');
152 dn = dn.substring(firstComma + 1);
153 }
154
155 return dn;
156 }
157
158 public boolean isClosed() {
159 throw new UnsupportedOperationException("Implement me.");
160 }
161
162 public void close() {
163 throw new UnsupportedOperationException("Implement me.");
164 }
165
166 public Transaction currentTransaction() {
167 throw new UnsupportedOperationException("Implement me.");
168 }
169
170 public void evict(Object arg0) {
171 throw new UnsupportedOperationException("Implement me.");
172 }
173
174 public void evictAll(Object[] arg0) {
175 throw new UnsupportedOperationException("Implement me.");
176 }
177
178 public void evictAll(Collection arg0) {
179 throw new UnsupportedOperationException("Implement me.");
180 }
181
182 public void evictAll() {
183 throw new UnsupportedOperationException("Implement me.");
184 }
185
186 public void refresh(Object arg0) {
187 throw new UnsupportedOperationException("Implement me.");
188 }
189
190 public void refreshAll(Object[] arg0) {
191 throw new UnsupportedOperationException("Implement me.");
192 }
193
194 public void refreshAll(Collection arg0) {
195 throw new UnsupportedOperationException("Implement me.");
196 }
197
198 public void refreshAll() {
199 throw new UnsupportedOperationException("Implement me.");
200 }
201
202 public Query newQuery() {
203 throw new UnsupportedOperationException("Implement me.");
204 }
205
206 public Query newQuery(Object arg0) {
207 throw new UnsupportedOperationException("Implement me.");
208 }
209
210 public Query newQuery(String arg0, Object arg1) {
211 throw new UnsupportedOperationException("Implement me.");
212 }
213
214 public Query newQuery(Class arg0) {
215 throw new UnsupportedOperationException("Implement me.");
216 }
217
218 public Query newQuery(Extent arg0) {
219 throw new UnsupportedOperationException("Implement me.");
220 }
221
222 public Query newQuery(Class arg0, Collection arg1) {
223 throw new UnsupportedOperationException("Implement me.");
224 }
225
226 public Query newQuery(Class arg0, String arg1) {
227 throw new UnsupportedOperationException("Implement me.");
228 }
229
230 public Query newQuery(Class arg0, Collection arg1, String arg2) {
231 throw new UnsupportedOperationException("Implement me.");
232 }
233
234 public Query newQuery(Extent arg0, String arg1) {
235 throw new UnsupportedOperationException("Implement me.");
236 }
237
238 public Extent getExtent(Class arg0, boolean arg1) {
239 throw new UnsupportedOperationException("Implement me.");
240 }
241
242 public Object getObjectById(Object arg0, boolean arg1) {
243 throw new UnsupportedOperationException("Implement me.");
244 }
245
246 public Object getObjectId(Object arg0) {
247 throw new UnsupportedOperationException("Implement me.");
248 }
249
250 public Object getTransactionalObjectId(Object arg0) {
251 throw new UnsupportedOperationException("Implement me.");
252 }
253
254 public Object newObjectIdInstance(Class arg0, String arg1) {
255 throw new UnsupportedOperationException("Implement me.");
256 }
257
258 public void makePersistent(Object object) {
259 store(object);
260 }
261
262 public void makePersistentAll(Object[] objects) {
263 for (int index = 0; index < objects.length; index++) {
264 makePersistent(objects[index]);
265 }
266 }
267
268 public void makePersistentAll(Collection objects) {
269 for (Iterator iterator = objects.iterator(); iterator.hasNext();) {
270 makePersistent(iterator.next());
271 }
272 }
273
274 public void deletePersistent(Object object) {
275 delete(object);
276 }
277
278 public void deletePersistentAll(Object[] objects) {
279 for (int index = 0; index < objects.length; index++) {
280 deletePersistent(objects[index]);
281 }
282 }
283
284 public void deletePersistentAll(Collection objects) {
285 for (Iterator iterator = objects.iterator(); iterator.hasNext();) {
286 deletePersistent(iterator.next());
287 }
288 }
289
290 public void makeTransient(Object arg0) {
291 throw new UnsupportedOperationException("Implement me.");
292 }
293
294 public void makeTransientAll(Object[] arg0) {
295 throw new UnsupportedOperationException("Implement me.");
296 }
297
298 public void makeTransientAll(Collection arg0) {
299 throw new UnsupportedOperationException("Implement me.");
300 }
301
302 public void makeTransactional(Object arg0) {
303 throw new UnsupportedOperationException("Implement me.");
304 }
305
306 public void makeTransactionalAll(Object[] arg0) {
307 throw new UnsupportedOperationException("Implement me.");
308 }
309
310 public void makeTransactionalAll(Collection arg0) {
311 throw new UnsupportedOperationException("Implement me.");
312 }
313
314 public void makeNontransactional(Object arg0) {
315 throw new UnsupportedOperationException("Implement me.");
316 }
317
318 public void makeNontransactionalAll(Object[] arg0) {
319 throw new UnsupportedOperationException("Implement me.");
320 }
321
322 public void makeNontransactionalAll(Collection arg0) {
323 throw new UnsupportedOperationException("Implement me.");
324 }
325
326 public void retrieve(Object arg0) {
327 throw new UnsupportedOperationException("Implement me.");
328 }
329
330 public void retrieveAll(Collection arg0) {
331 throw new UnsupportedOperationException("Implement me.");
332 }
333
334 public void retrieveAll(Object[] arg0) {
335 throw new UnsupportedOperationException("Implement me.");
336 }
337
338 public void setUserObject(Object arg0) {
339 throw new UnsupportedOperationException("Implement me.");
340 }
341
342 public Object getUserObject() {
343 throw new UnsupportedOperationException("Implement me.");
344 }
345
346 public PersistenceManagerFactory getPersistenceManagerFactory() {
347 throw new UnsupportedOperationException("Implement me.");
348 }
349
350 public Class getObjectIdClass(Class arg0) {
351 throw new UnsupportedOperationException("Implement me.");
352 }
353
354 public void setMultithreaded(boolean arg0) {
355 throw new UnsupportedOperationException("Implement me.");
356 }
357
358 public boolean getMultithreaded() {
359 throw new UnsupportedOperationException("Implement me.");
360 }
361
362 public void setIgnoreCache(boolean arg0) {
363 throw new UnsupportedOperationException("Implement me.");
364 }
365
366 public boolean getIgnoreCache() {
367 throw new UnsupportedOperationException("Implement me.");
368 }
369 }