This is an implementation of the RegistryService
* based on the Castor XML serialization mechanisms
This registry aggregates multiple RegistryFragment to store the regsistry * entries
* *This service expects the following properties to be set for correct operation: *
Service framework
*/
public void init(ServletConfig conf) throws InitializationException
{
//Ensure that the servlet service is initialized
TurbineServices.getInstance().initService(ServletService.SERVICE_NAME, conf);
ResourceService serviceConf = ((TurbineServices) TurbineServices.getInstance())
.getResources(RegistryService.SERVICE_NAME);
String mapFile = null;
Vector names = new Vector();
int refreshRate = 0;
// read the configuration keys
try
{
directory = serviceConf.getString("directory");
mapFile = serviceConf.getString("mapping", DEFAULT_MAPPING);
extension = serviceConf.getString("extension", DEFAULT_EXTENSION);
refreshRate = serviceConf.getInt("refreshRate", DEFAULT_REFRESH);
mapFile = TurbineServlet.getRealPath(mapFile);
directory = TurbineServlet.getRealPath(directory);
}
catch (Throwable t)
{
throw new InitializationException("Unable to initialize CastorRegistryService, missing config keys");
}
// build the map of default fragments, eahc registry must be associated
// with at least one fragment
try
{
ResourceService defaults = serviceConf.getResources("default");
Iterator i = defaults.getKeys();
while (i.hasNext())
{
String name = (String) i.next();
String fragmentFileName = defaults.getString(name);
String absFileName = new File(directory, fragmentFileName + extension).getAbsolutePath();
// add this name in the list of available registries
names.add(name);
// store the default file mapping
this.defaults.put(name, absFileName);
}
}
catch (Exception e)
{
Log.error("Registry init error", e);
throw new InitializationException("Unable to initialize CastorRegistryService, invalid registries definition");
}
// create the serializer output format
this.format = new OutputFormat();
format.setIndenting(true);
format.setIndent(4);
// test the mapping file and create the mapping object
if (mapFile != null)
{
File map = new File(mapFile);
if (map.exists() && map.isFile() && map.canRead())
{
try
{
mapping = new Mapping();
InputSource is = new InputSource(new FileReader(map));
is.setSystemId(mapFile);
mapping.loadMapping(is);
}
catch (Exception e)
{
Log.error("Error in mapping creation", e);
throw new InitializationException("Error in mapping", e);
}
}
else
{
throw new InitializationException("Mapping not found or not a file or unreadable: " + mapFile);
}
}
// Set directory watcher if directory exists
File base = new File(directory);
File[] files = null;
if (base.exists() && base.isDirectory() && base.canRead())
{
this.watcher = new RegistryWatcher();
this.watcher.setSubscriber(this);
this.watcher.setFilter(new ExtFileFilter(extension));
if (refreshRate == 0)
{
this.watcher.setDone();
}
else
{
this.watcher.setRefreshRate(refreshRate);
}
// changing the base will trigger a synchronous loading of the fragments
this.watcher.changeBase(base);
}
//Mark that we are done
setInit(true);
// load the registries
Enumeration en = names.elements();
while (en.hasMoreElements())
{
String name = (String) en.nextElement();
Registry registry = (Registry) registries.get(name);
if (registry == null)
{
if (name.equals(org.apache.jetspeed.services.Registry.PORTLET))
{
registry = new BasePortletRegistry();
}
else
{
registry = new BaseRegistry();
}
registries.put(name, registry);
}
refresh(name);
}
// Refresh the registry to make sure all Service framework
*/
public void shutdown()
{
this.watcher.setDone();
Iterator i = fragments.keySet().iterator();
while (i.hasNext())
{
saveFragment((String) i.next());
}
}
// FileRegistry interface
/** Refresh the state of the registry implementation. Should be called
* whenever the underlying fragments are modified
*/
public void refresh()
{
Enumeration en = getNames();
while (en.hasMoreElements())
{
refresh((String) en.nextElement());
}
}
/**
* Load and unmarshal a RegistryFragment from the file
* @param file the absolute file path storing this fragment
*/
public void loadFragment(String file)
{
FileReader reader = null;
try
{
/*DocumentBuilderFactory dbfactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dbfactory.newDocumentBuilder();
Document d = builder.parse(file);
Unmarshaller unmarshaller = new Unmarshaller(this.mapping);
RegistryFragment fragment = (RegistryFragment) unmarshaller.unmarshal((Node) d);
// if we get here, we successfully loaded the new fragment
updateFragment(file, fragment);*/
Unmarshaller unmarshaller = new Unmarshaller(this.mapping);
reader = new FileReader(file);
RegistryFragment fragment = (RegistryFragment)unmarshaller.unmarshal(reader);
// if we get here, we successfully loaded the new fragment
updateFragment(file, fragment);
}
catch (Throwable t)
{
Log.error("Could not unmarshal: " + file, t);
}
}
/**
* Read and unmarshal a fragment in memory
* @param name the name of this fragment
* @param reader the reader to use for creating this fragment
* @param persistent whether this fragment should be persisted on disk in
* the registry
*/
public void createFragment(String name, Reader reader, boolean persistent)
{
String file = new File(directory, name + extension).getAbsolutePath();
try
{
Unmarshaller unmarshaller = new Unmarshaller(this.mapping);
RegistryFragment fragment = (RegistryFragment) unmarshaller.unmarshal(reader);
updateFragment(file, fragment);
if (persistent)
{
saveFragment(file);
}
}
catch (Throwable t)
{
Log.error("Could not create fragment: " + file, t);
}
finally
{
try
{
reader.close();
}
catch (Exception e)
{
Log.error(e); // At least log the exception.
}
}
// refresh all regsitries to take the new entries into account
refresh();
}
/**
* Marshal and save a RegistryFragment to disk
* @param file the absolute file path storing this fragment
*/
public void saveFragment(String file)
{
OutputStreamWriter writer = null;
String encoding = new String("UTF-8");
RegistryFragment fragment = (RegistryFragment) fragments.get(file);
if (fragment != null)
{
try
{
writer = new OutputStreamWriter(new FileOutputStream(file), encoding);
format.setEncoding(encoding);
Serializer serializer = new XMLSerializer(writer, format);
Marshaller marshaller = new Marshaller(serializer.asDocumentHandler());
marshaller.setMapping(this.mapping);
marshaller.marshal(fragment);
}
catch (Throwable t)
{
Log.error("Could not marshal: " + file, t);
}
finally
{
try
{
writer.close();
}
catch (Exception e)
{
Log.error(e); // At least log the exception.
}
}
}
}
/**
* Remove a fragment from storage
* @param file the absolute file path storing this fragment
*/
public void removeFragment(String file)
{
RegistryFragment fragment = (RegistryFragment) fragments.get(file);
if (fragment != null)
{
synchronized (entryIndex)
{
// clear the entry index
Iterator i = entryIndex.keySet().iterator();
while (i.hasNext())
{
if (file.equals(entryIndex.get(i.next())))
{
i.remove();
}
}
// make sure the keys & entries are freed for this fragment
// only the entries not replaced by the next registry refresh will
// stay in memory
fragment.clear();
// remove the actual fragment from memory
fragments.remove(file);
}
}
}
// Implementation specific methods
/**
* Updates a fragment in storage and the associated entryIndex
*/
protected void updateFragment(String name, RegistryFragment fragment)
{
synchronized (entryIndex)
{
// remove the old keys
Iterator i = entryIndex.keySet().iterator();
while (i.hasNext())
{
if (name.equals(entryIndex.get(i.next())))
{
i.remove();
}
}
// store the new fragment
fragments.put(name, fragment);
// recreate the index entries (only this fragment)
Enumeration enum = fragment.keys();
while (enum.hasMoreElements())
{
String strReg = (String) enum.nextElement();
Vector v = fragment.getEntries(strReg);
for (int counter = 0; counter < v.size(); counter++)
{
RegistryEntry str = (RegistryEntry) v.elementAt(counter);
entryIndex.put(str.getName(), name);
}
}
}
}
/**
* Scan all the registry fragments for new entries relevant to
* this registry and update its definition.
*
* @param regName the name of the Registry to refresh
*/
protected void refresh(String regName)
{
Log.debug("Updating the " + regName + " registry");
int count = 0;
Registry registry = get(regName);
if (registry == null)
{
Log.error("Null " + name + " registry in refresh");
return;
}
// for each fragment...
Enumeration en = fragments.keys();
while (en.hasMoreElements())
{
String location = (String) en.nextElement();
RegistryFragment fragment = (RegistryFragment) fragments.get(location);
Vector entries = fragment.getEntries(regName);
//... if it has entries related to this regsistry,
if (entries != null)
{
// for all these entries
Enumeration en2 = entries.elements();
while (en2.hasMoreElements())
{
RegistryEntry entry = (RegistryEntry) en2.nextElement();
// update or add the entry in the registry
try
{
Log.debug("Adding entry " + entry.getName() + " of class " + entry.getClass() + " to registry " + name);
if (registry.hasEntry(entry.getName()))
{
registry.setEntry(entry);
}
else
{
registry.addEntry(entry);
}
// Initialize the entry index
this.entryIndex.put(entry.getName(), location);
++count;
}
catch (RegistryException e)
{
Log.error("RegistryException while adding " + entry.getName() + "from " + location, e);
}
}
}
}
Log.debug("Merged " + count + " entries into the " + name);
}
/** FileFilter implementing a file extension based filter */
class ExtFileFilter implements FileFilter
{
private String extension = null;
ExtFileFilter(String extension)
{
this.extension = extension;
}
public boolean accept(File f)
{
return f.toString().endsWith(extension);
}
}
}