KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > jetspeed > services > registry > CastorRegistryService


1 /*
2  * Copyright 2000-2001,2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package org.apache.jetspeed.services.registry;
18
19 // Jetspeed stuff
20 import org.apache.jetspeed.services.logging.JetspeedLogFactoryService;
21 import org.apache.jetspeed.services.logging.JetspeedLogger;
22 import org.apache.jetspeed.om.registry.Registry;
23 import org.apache.jetspeed.om.registry.RegistryEntry;
24 import org.apache.jetspeed.om.registry.RegistryException;
25 import org.apache.jetspeed.om.registry.base.BaseRegistry;
26 import org.apache.jetspeed.om.registry.base.LocalRegistry;
27
28 //turbine stuff
29 import org.apache.turbine.services.InitializationException;
30 import org.apache.turbine.services.TurbineBaseService;
31 import org.apache.turbine.services.TurbineServices;
32 import org.apache.turbine.services.servlet.TurbineServlet;
33 import org.apache.turbine.services.servlet.ServletService;
34 import org.apache.turbine.services.resources.ResourceService;
35
36 // castor marshalling
37 import org.exolab.castor.mapping.Mapping;
38 import org.exolab.castor.xml.Unmarshaller;
39 import org.exolab.castor.xml.Marshaller;
40 import org.xml.sax.InputSource;
41 import org.apache.xml.serialize.Serializer;
42 import org.apache.xml.serialize.XMLSerializer;
43 import org.apache.xml.serialize.OutputFormat;
44 import org.w3c.dom.Document;
45 import org.w3c.dom.Node;
46
47 //java stuff
48 import java.io.File;
49 import java.io.FileFilter;
50 import java.io.FileReader;
51 import java.io.FileOutputStream;
52 import java.io.OutputStreamWriter;
53 import java.io.Reader;
54 import java.util.Enumeration;
55 import java.util.Hashtable;
56 import java.util.Map;
57 import java.util.Iterator;
58 import java.util.Vector;
59 import javax.servlet.ServletConfig;
60 import javax.xml.parsers.DocumentBuilder;
61 import javax.xml.parsers.DocumentBuilderFactory;
62
63 /**
64  * <p>This is an implementation of the <code>RegistryService</code>
65  * based on the Castor XML serialization mechanisms</p>
66  * <p>This registry aggregates multiple RegistryFragment to store the regsistry
67  * entries</p>
68  *
69  * <p>This service expects the following properties to be set for correct operation:
70  * <dl>
71  * <dt>directory</dt><dd>The directory where the Registry will look for
72  * fragment files</dd>
73  * <dt>extension</dt><dd>The extension used for identifying the registry fragment
74  * files. Default .xreg</dd>
75  * <dt>mapping</dt><dd>the Castor object mapping file path</dd>
76  * <dt>registries</dt><dd>a comma separated list of registry names to load
77  * from this file</dd>
78  * <dt>refreshRate</dt><dd>Optional. The manager will check every
79  * refreshRate seconds if the config has changed and if true will refresh
80  * all the registries. A value of 0 or negative will disable the
81  * automatic refresh operation. Default: 300 (5 minutes)</dd>
82   * </dl>
83  * </p>
84  *
85  * @author <a HREF="mailto:raphael@apache.org">Raphaël Luta</a>
86  * @author <a HREF="mailto:sgala@apache.org">Santiago Gala</a>
87  * @version $Id: CastorRegistryService.java,v 1.37 2004/03/31 00:23:02 jford Exp $
88  */
89 public class CastorRegistryService
90     extends TurbineBaseService
91     implements RegistryService, FileRegistry
92 {
93     /**
94      * Static initialization of the logger for this class
95      */
96     private static final JetspeedLogger logger = JetspeedLogFactoryService.getLogger(CastorRegistryService.class.getName());
97     
98     public static final int DEFAULT_REFRESH = 300;
99     public static final String DEFAULT_EXTENSION = ".xreg";
100     public static final String DEFAULT_MAPPING = "${webapp}/WEB-INF/conf/mapping.xml";
101
102     /** regsitry type keyed list of entries */
103     private Hashtable registries = new Hashtable();
104
105     /** The Castor generated RegsitryFragment objects */
106     private Hashtable fragments = new Hashtable();
107
108     /** The list of default fragments stores for newly created objects */
109     private Hashtable defaults = new Hashtable();
110
111     /** Associates entries with their fragments name for quick lookup */
112     private Hashtable entryIndex = new Hashtable();
113
114     /** the Watcher object which monitors the regsitry directory */
115     private RegistryWatcher watcher = null;
116
117     /** the Castor mapping file name */
118     private Mapping mapping = null;
119
120     /** the output format for pretty printing when saving registries */
121     private OutputFormat format = null;
122
123     /** the base regsitry directory */
124     private String directory = null;
125
126     /** the extension for registry files */
127     private String extension = null;
128
129     /**
130      * Returns a Registry object for further manipulation
131      *
132      * @param regName the name of the registry to fetch
133      * @return a Registry object if found by the manager or null
134      */
135     public Registry get(String regName)
136     {
137         return (Registry) registries.get(regName);
138     }
139
140     /**
141      * List all the registry currently available to this service
142      *
143      * @return an Enumeration of registry names.
144      */
145     public Enumeration getNames()
146     {
147         return registries.keys();
148     }
149
150     /**
151      * Creates a new RegistryEntry instance compatible with the current
152      * Registry instance implementation
153      *
154      * @param regName the name of the registry to use
155      * @return the newly created RegistryEntry
156      */
157     public RegistryEntry createEntry(String regName)
158     {
159                 RegistryEntry entry = null;
160         Registry registry = (Registry) registries.get(regName);
161
162         if (registry != null)
163         {
164             entry = registry.createEntry();
165         }
166
167         return entry;
168     }
169
170     /**
171      * Returns a RegistryEntry from the named Registry.
172      * This is a convenience wrapper around {@link
173      * org.apache.jetspeed.om.registry.Registry#getEntry }
174      *
175      * @param regName the name of the registry
176      * @param entryName the name of the entry to retrieve from the
177      * registry
178      * @return a RegistryEntry object if the key is found or null
179      */
180     public RegistryEntry getEntry(String regName, String entryName)
181     {
182         try
183         {
184             return ((Registry) registries.get(regName)).getEntry(entryName);
185         }
186         catch (RegistryException e)
187         {
188             if (logger.isInfoEnabled())
189             {
190                 logger.info("RegistryService: Failed to retrieve " + entryName + " from " + regName);
191             }
192         }
193         catch (NullPointerException e)
194         {
195             logger.error("RegistryService: " + regName + " registry is not known ", e);
196         }
197
198         return null;
199     }
200
201     /**
202      * Add a new RegistryEntry in the named Registry.
203      * This is a convenience wrapper around {@link
204      * org.apache.jetspeed.om.registry.Registry#addEntry }
205      *
206      * @param regName the name of the registry
207      * @param entry the Registry entry to add
208      * @exception Sends a RegistryException if the manager can't add
209      * the provided entry
210      */
211     public void addEntry(String regName, RegistryEntry entry) throws RegistryException
212     {
213         if (entry == null)
214         {
215             return;
216         }
217
218         LocalRegistry registry = (LocalRegistry) registries.get(regName);
219
220         if (registry != null)
221         {
222             String fragmentName = (String) entryIndex.get(entry.getName());
223
224             if (fragmentName == null)
225             {
226                 // either the entry was deleted or it does not exist
227 // in both cases, use the default fragment
228 fragmentName = (String) defaults.get(regName);
229             }
230
231             RegistryFragment fragment = (RegistryFragment) fragments.get(fragmentName);
232
233             //Fragment can be (and sometimes is, but should not be) null
234 if (fragment == null)
235             {
236                 fragment = new RegistryFragment();
237                 fragment.put(regName, new Vector());
238                 fragments.put(fragmentName, fragment);
239             }
240             else
241             {
242                 Vector vectRegistry = (Vector) fragment.get(regName);
243                 if (vectRegistry == null)
244                 {
245                     fragment.put(regName, new Vector());
246                 }
247             }
248
249             synchronized (entryIndex)
250             {
251                 if (registry.hasEntry(entry.getName()))
252                 {
253                     fragment.setEntry(regName, entry);
254                     registry.setLocalEntry(entry);
255                 }
256                 else
257                 {
258                     fragment.addEntry(regName, entry);
259                     registry.addLocalEntry(entry);
260                 }
261
262                 entryIndex.put(entry.getName(), fragmentName);
263                 // mark this fragment so that it's persisted next time
264 // the registry watcher is running
265 fragment.setDirty(true);
266             }
267         }
268     }
269
270     /**
271      * Deletes a RegistryEntry from the named Registry
272      * This is a convenience wrapper around {@link
273      * org.apache.jetspeed.om.registry.Registry#removeEntry }
274      *
275      * @param regName the name of the registry
276      * @param entryName the name of the entry to remove
277      */
278     public void removeEntry(String regName, String entryName)
279     {
280         if (entryName == null)
281         {
282             return;
283         }
284
285         LocalRegistry registry = (LocalRegistry) registries.get(regName);
286
287         if (registry != null)
288         {
289             String fragmentName = (String) entryIndex.get(entryName);
290
291             if (fragmentName != null)
292             {
293                 RegistryFragment fragment = (RegistryFragment) fragments.get(fragmentName);
294
295                 synchronized (entryIndex)
296                 {
297                     fragment.removeEntry(regName, entryName);
298                     entryIndex.remove(entryName);
299
300                     // mark this fragment so that it's persisted next time
301 // the registry watcher is running
302 fragment.setDirty(true);
303                 }
304             }
305
306             // the entry is physically removed, remove the dangling reference
307 registry.removeLocalEntry(entryName);
308         }
309     }
310
311     /**
312      * This is the early initialization method called by the
313      * Turbine <code>Service</code> framework
314      */
315     public synchronized void init(ServletConfig conf) throws InitializationException
316     {
317
318         //Ensure that the servlet service is initialized
319 TurbineServices.getInstance().initService(ServletService.SERVICE_NAME, conf);
320
321         ResourceService serviceConf = ((TurbineServices) TurbineServices.getInstance())
322                                                      .getResources(RegistryService.SERVICE_NAME);
323         String mapFile = null;
324         Vector names = new Vector();
325         int refreshRate = 0;
326
327         // read the configuration keys
328 try
329         {
330             directory = serviceConf.getString("directory");
331             mapFile = serviceConf.getString("mapping", DEFAULT_MAPPING);
332             extension = serviceConf.getString("extension", DEFAULT_EXTENSION);
333             refreshRate = serviceConf.getInt("refreshRate", DEFAULT_REFRESH);
334
335             mapFile = TurbineServlet.getRealPath(mapFile);
336             directory = TurbineServlet.getRealPath(directory);
337         }
338         catch (Throwable t)
339         {
340             throw new InitializationException("Unable to initialize CastorRegistryService, missing config keys");
341         }
342
343         // build the map of default fragments, eahc registry must be associated
344 // with at least one fragment
345 try
346         {
347             ResourceService defaults = serviceConf.getResources("default");
348             Iterator i = defaults.getKeys();
349             while (i.hasNext())
350             {
351                 String name = (String) i.next();
352                 String fragmentFileName = defaults.getString(name);
353
354                 String absFileName = new File(directory, fragmentFileName + extension).getCanonicalPath();
355                 // add this name in the list of available registries
356 names.add(name);
357
358                 // store the default file mapping
359 this.defaults.put(name, absFileName);
360             }
361         }
362         catch (Exception e)
363         {
364             logger.error("RegistryService: Registry init error", e);
365             throw new InitializationException("Unable to initialize CastorRegistryService, invalid registries definition");
366         }
367
368         // create the serializer output format
369 this.format = new OutputFormat();
370         format.setIndenting(true);
371         format.setIndent(4);
372         format.setLineWidth(0);
373
374         // test the mapping file and create the mapping object
375
376         if (mapFile != null)
377         {
378             File map = new File(mapFile);
379             if (map.exists() && map.isFile() && map.canRead())
380             {
381                 try
382                 {
383                     mapping = new Mapping();
384                     InputSource is = new InputSource(new FileReader(map));
385                     is.setSystemId(mapFile);
386                     mapping.loadMapping(is);
387                 }
388                 catch (Exception e)
389                 {
390                     logger.error("RegistryService: Error in mapping creation", e);
391                     throw new InitializationException("Error in mapping", e);
392                 }
393             }
394             else
395             {
396                 throw new InitializationException("Mapping not found or not a file or unreadable: " + mapFile);
397             }
398         }
399
400         // Set directory watcher if directory exists
401 File base = new File(directory);
402         File[] files = null;
403
404         if (base.exists() && base.isDirectory() && base.canRead())
405         {
406             this.watcher = new RegistryWatcher();
407             this.watcher.setSubscriber(this);
408             this.watcher.setFilter(new ExtFileFilter(extension));
409             if (refreshRate == 0)
410             {
411                 this.watcher.setDone();
412             }
413             else
414             {
415                 this.watcher.setRefreshRate(refreshRate);
416             }
417             // changing the base will trigger a synchronous loading of the fragments
418 this.watcher.changeBase(base);
419         }
420
421         //Mark that we are done
422 setInit(true);
423
424
425         // load the registries
426 Enumeration en = names.elements();
427
428         while (en.hasMoreElements())
429         {
430             String name = (String) en.nextElement();
431             Registry registry = (Registry) registries.get(name);
432
433             if (registry == null)
434             {
435                 String registryClass = null;
436                 try
437                 {
438                     registryClass =
439                         "org.apache.jetspeed.om.registry.base.Base"
440                         + name
441                         + "Registry";
442
443                     registry = (Registry) Class.forName(registryClass).newInstance();
444                 }
445                 catch (Exception e)
446                 {
447                     if (logger.isWarnEnabled())
448                     {
449                         logger.warn("RegistryService: Class "
450                                     + registryClass
451                                     + " not found, reverting to default Registry");
452                     }
453                     registry = new BaseRegistry();
454                 }
455
456                 registries.put(name, registry);
457             }
458
459             refresh(name);
460         }
461
462         // Start the directory watcher thread and rely on its refresh process
463 // to completely load all registries
464 if (this.watcher != null)
465         {
466             this.watcher.start();
467         }
468
469         if (logger.isDebugEnabled())
470         {
471             logger.debug("RegistryService: early init()....end!, this.getInit()= " + getInit());
472         }
473
474     }
475
476
477     /** Late init method from Turbine Service model */
478     public void init() throws InitializationException
479     {
480         if (logger.isDebugEnabled())
481         {
482             logger.debug("RegistryService: Late init called");
483         }
484
485         while (!getInit())
486         {
487             //Not yet...
488 try
489             {
490                 Thread.sleep(500);
491                 if (logger.isDebugEnabled())
492                 {
493                     logger.debug("RegistryService: Waiting for init of Registry...");
494                 }
495             }
496             catch (InterruptedException ie)
497             {
498                 logger.error("Exception", ie);
499             }
500         }
501
502         if (logger.isDebugEnabled())
503         {
504             logger.debug("RegistryService: We are done");
505         }
506     }
507
508     /**
509      * This is the shutdown method called by the
510      * Turbine <code>Service</code> framework
511      */
512     public void shutdown()
513     {
514         this.watcher.setDone();
515
516         Iterator i = fragments.keySet().iterator();
517         while (i.hasNext())
518         {
519             saveFragment((String) i.next());
520         }
521     }
522
523     // FileRegistry interface
524
525     /** Refresh the state of the registry implementation. Should be called
526      * whenever the underlying fragments are modified
527      */
528     public void refresh()
529     {
530         synchronized (watcher)
531         {
532             Enumeration en = getNames();
533             while (en.hasMoreElements())
534             {
535                 refresh((String) en.nextElement());
536             }
537         }
538     }
539
540     /**
541      * @return a Map of all fragments keyed by file names
542      */
543     public Map getFragmentMap()
544     {
545         return (Map) fragments.clone();
546     }
547
548     /**
549      * Load and unmarshal a RegistryFragment from the file
550      * @param file the absolute file path storing this fragment
551      */
552     public void loadFragment(String file)
553     {
554         try
555         {
556             DocumentBuilderFactory dbfactory = DocumentBuilderFactory.newInstance();
557             DocumentBuilder builder = dbfactory.newDocumentBuilder();
558        
559             Document d = builder.parse(new File(file));
560
561             Unmarshaller unmarshaller = new Unmarshaller(this.mapping);
562             RegistryFragment fragment = (RegistryFragment) unmarshaller.unmarshal((Node) d);
563
564             //mark this fragment as changed
565 fragment.setChanged(true);
566
567             // if we get here, we successfully loaded the new fragment
568 updateFragment(file, fragment);
569
570         }
571         catch (Throwable t)
572         {
573             logger.error("RegistryService: Could not unmarshal: " + file, t);
574         }
575
576     }
577
578     /**
579      * Read and unmarshal a fragment in memory
580      * @param name the name of this fragment
581      * @param reader the reader to use for creating this fragment
582      * @param persistent whether this fragment should be persisted on disk in
583      * the registry
584      */
585     public void createFragment(String name, Reader reader, boolean persistent)
586     {
587         String file = null;
588
589         try
590         {
591             synchronized(watcher)
592             {
593                 file = new File(directory, name + extension).getCanonicalPath();
594     
595                 Unmarshaller unmarshaller = new Unmarshaller(this.mapping);
596                 RegistryFragment fragment = (RegistryFragment) unmarshaller.unmarshal(reader);
597     
598                 fragment.setChanged(true);
599     
600                 updateFragment(file, fragment);
601     
602                 if (persistent)
603                 {
604                     saveFragment(file);
605                 }
606             }
607         }
608         catch (Throwable t)
609         {
610             logger.error("RegistryService: Could not create fragment: " + file, t);
611         }
612         finally
613         {
614             try
615             {
616                 reader.close();
617             }
618             catch (Exception e)
619             {
620                 logger.error("Exception", e); // At least log the exception.
621 }
622         }
623     }
624
625     /**
626      * Marshal and save a RegistryFragment to disk
627      * @param file the absolute file path storing this fragment
628      */
629     public void saveFragment(String file)
630     {
631         OutputStreamWriter writer = null;
632         FileOutputStream fos = null;
633         String encoding = new String("UTF-8");
634         RegistryFragment fragment = (RegistryFragment) fragments.get(file);
635
636         if (fragment != null)
637         {
638             try
639             {
640                 fos = new FileOutputStream(file);
641                 writer = new OutputStreamWriter(fos, encoding);
642                 format.setEncoding(encoding);
643                 Serializer serializer = new XMLSerializer(writer, format);
644                 Marshaller marshaller = new Marshaller(serializer.asDocumentHandler());
645                 marshaller.setMapping(this.mapping);
646                 marshaller.marshal(fragment);
647             }
648             catch (Throwable t)
649             {
650                 logger.error("RegistryService: Could not marshal: " + file, t);
651             }
652             finally
653             {
654                 try
655                 {
656                     writer.close();
657                 }
658                 catch (Exception e)
659                 {
660                     logger.error("Exception", e); // At least log the exception.
661 }
662                 
663                 try
664                 {
665                     fos.close();
666                 }
667                 catch (Exception e)
668                 {
669                     logger.error("Exception", e); // At least log the exception.
670 }
671             }
672         }
673     }
674
675     /**
676      * Remove a fragment from storage
677      * @param file the absolute file path storing this fragment
678      */
679     public void removeFragment(String file)
680     {
681         RegistryFragment fragment = (RegistryFragment) fragments.get(file);
682
683         if (fragment != null)
684         {
685             synchronized (entryIndex)
686             {
687                 // clear the entry index
688 Iterator i = entryIndex.keySet().iterator();
689                 while (i.hasNext())
690                 {
691                     if (file.equals(entryIndex.get(i.next())))
692                     {
693                         i.remove();
694                     }
695                 }
696
697                 // make sure the keys & entries are freed for this fragment
698 // only the entries not replaced by the next registry refresh will
699 // stay in memory
700 fragment.clear();
701                 // remove the actual fragment from memory
702 fragments.remove(file);
703             }
704         }
705     }
706
707     // Implementation specific methods
708
709     /**
710      * Updates a fragment in storage and the associated entryIndex
711      */
712     protected void updateFragment(String name, RegistryFragment fragment)
713     {
714         synchronized (entryIndex)
715         {
716             // remove the old keys
717 Iterator i = entryIndex.keySet().iterator();
718             while (i.hasNext())
719             {
720                 if (name.equals(entryIndex.get(i.next())))
721                 {
722                     i.remove();
723                 }
724             }
725
726             // store the new fragment
727 fragments.put(name, fragment);
728
729             // recreate the index entries (only this fragment)
730
731             Enumeration enum = fragment.keys();
732             while (enum.hasMoreElements())
733             {
734                 String strReg = (String) enum.nextElement();
735                 Vector v = fragment.getEntries(strReg);
736
737                 for (int counter = 0; counter < v.size(); counter++)
738                 {
739                     RegistryEntry str = (RegistryEntry) v.elementAt(counter);
740                     entryIndex.put(str.getName(), name);
741                 }
742             }
743         }
744     }
745
746     /**
747      * Scan all the registry fragments for new entries relevant to
748      * this registry and update its definition.
749      *
750      * @param regName the name of the Registry to refresh
751      */
752     protected void refresh(String regName)
753     {
754
755         if (logger.isDebugEnabled())
756         {
757             logger.debug("RegistryService: Updating the " + regName + " registry");
758         }
759
760         int count = 0;
761         int counDeleted = 0;
762         LocalRegistry registry = (LocalRegistry) get(regName);
763
764         Vector toDelete = new Vector();
765         Iterator i = registry.listEntryNames();
766
767         while (i.hasNext())
768         {
769             toDelete.add(i.next());
770         }
771
772         if (registry == null)
773         {
774             logger.error("RegistryService: Null " + name + " registry in refresh");
775             return;
776         }
777
778         // for each fragment...
779 Enumeration en = fragments.keys();
780         while (en.hasMoreElements())
781         {
782             String location = (String) en.nextElement();
783             RegistryFragment fragment = (RegistryFragment) fragments.get(location);
784             int fragCount = 0;
785
786             if (!fragment.hasChanged())
787             {
788                 if (logger.isDebugEnabled())
789                 {
790                     logger.debug("RegistryService: Skipping fragment " + location);
791                 }
792
793                 //remove this fragment entries from the delete list
794 Vector entries = fragment.getEntries(regName);
795                 i = entries.iterator();
796                 while (i.hasNext())
797                 {
798                     toDelete.remove(((RegistryEntry) i.next()).getName());
799                 }
800
801                 continue;
802             }
803
804             //the fragment has some changes, iterate over its entries...
805
806             Vector entries = fragment.getEntries(regName);
807
808             //... if it has entries related to this regsistry,
809 if (entries != null)
810             {
811                 // for all these entries
812 Enumeration en2 = entries.elements();
813                 while (en2.hasMoreElements())
814                 {
815                     RegistryEntry entry = (RegistryEntry) en2.nextElement();
816                     // update or add the entry in the registry
817 try
818                     {
819                         if (registry.hasEntry(entry.getName()))
820                         {
821                             if (registry.getEntry(entry.getName()).equals(entry))
822                             {
823                                 if (logger.isDebugEnabled())
824                                 {
825                                     logger.debug("RegistryService: No changes to entry " + entry.getName());
826                                 }
827                             }
828                             else
829                             {
830                                 if (logger.isDebugEnabled())
831                                 {
832                                     logger.debug("RegistryService: Updating entry " + entry.getName()
833                                         + " of class " + entry.getClass() + " to registry " + name);
834                                 }
835
836                                 registry.setLocalEntry(entry);
837                                 // Initialize the entry index
838 this.entryIndex.put(entry.getName(), location);
839                                 ++fragCount;
840                             }
841                         }
842                         else
843                         {
844                             registry.addLocalEntry(entry);
845                             // Initialize the entry index
846 this.entryIndex.put(entry.getName(), location);
847                             ++fragCount;
848
849                             if (logger.isDebugEnabled())
850                             {
851                                 logger.debug("RegistryService: Adding entry " + entry.getName() + " of class "
852                                     + entry.getClass() + " to registry " + name);
853                             }
854                         }
855                     }
856                     catch (RegistryException e)
857                     {
858                         logger.error("RegistryService: RegistryException while adding " + entry.getName() + "from " + location, e);
859                     }
860
861                     //remove this entry from the delete list
862 toDelete.remove(entry.getName());
863                 }
864             }
865
866             count += fragCount;
867         }
868
869         //now delete the entries not found in any fragment
870 i = toDelete.iterator();
871         while (i.hasNext())
872         {
873             String entryName = (String) i.next();
874
875             if (logger.isDebugEnabled())
876             {
877                 logger.debug("RegistryService: removing entry " + entryName);
878             }
879
880             registry.removeLocalEntry(entryName);
881         }
882
883
884         if (logger.isDebugEnabled())
885         {
886             logger.debug("RegistryService: Merged " + count + " entries and deleted " + toDelete.size() + " in " + name);
887         }
888     }
889
890
891     /** FileFilter implementing a file extension based filter */
892     class ExtFileFilter implements FileFilter
893     {
894         private String extension = null;
895
896         ExtFileFilter(String extension)
897         {
898             this.extension = extension;
899         }
900
901         public boolean accept(File f)
902         {
903             return f.toString().endsWith(extension);
904         }
905     }
906
907 }
908
Popular Tags