try 
            {
                Thread.sleep(500);
                if ((verbose > 2) && logger.isDebugEnabled()) 
                {
                    logger.debug(
                        "DatabaseRegistryService: Waiting for init of Registry...");
                }
            } 
            catch (InterruptedException ie) 
            {
                logger.error(ie);
            }
        }

        if (logger.isDebugEnabled()) 
        {
            logger.debug("DatabaseRegistryService: We are done");
        }
    }
    
    /**
     * This is the shutdown method called by the
     * Turbine <code>Service</code> framework
     */
    public void shutdown() 
    {
        this.watcher.setDone();

        Iterator i = fragments.keySet().iterator();
        while (i.hasNext()) 
        {
            saveFragment((String) i.next());
        }
    }

    /**
     * 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) 
    {
        if (logger.isDebugEnabled()) 
        {
            logger.debug(
                "DatabaseRegistryService: Updating the "
                    + regName
                    + " registry");
        }

        int count = 0;
        int counDeleted = 0;
        LocalRegistry registry = (LocalRegistry) get(regName);

        Vector toDelete = new Vector();
        Iterator i = registry.listEntryNames();

        while (i.hasNext()) 
        {
            toDelete.add(i.next());
        }

        if (registry == null) 
        {
            logger.error(
                "DatabaseRegistryService: 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);
            int fragCount = 0;

            if (!fragment.hasChanged()) 
            {
                if ((verbose > 2) && logger.isDebugEnabled()) 
                {
                    logger.debug(
                        "DatabaseRegistryService: Skipping fragment "
                            + location);
                }

                //remove this fragment entries from the delete list
                Vector entries = fragment.getEntries(regName);
                i = entries.iterator();
                while (i.hasNext()) 
                {
                    toDelete.remove(((RegistryEntry) i.next()).getName());
                }
                continue;
            }

            //the fragment has some changes, iterate over its entries...
            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 
                    {
                        if (registry.hasEntry(entry.getName())) 
                        {
                            if (registry
                                .getEntry(entry.getName())
                                .equals(entry)) 
                            {
                                if ((verbose > 2)
                                    && logger.isDebugEnabled()) 
                                {
                                    logger.debug(
                                        "DatabaseRegistryService: No changes to entry "
                                            + entry.getName());
                                }
                            } 
                            else 
                            {
                                if ((verbose > 1)
                                    && logger.isDebugEnabled()) 
                                {
                                    logger.debug(
                                        "DatabaseRegistryService: Updating entry "
                                            + entry.getName()
                                            + " of class "
                                            + entry.getClass()
                                            + " to registry "
                                            + name);
                                }
                                registry.setLocalEntry(entry);
                                // Initialize the entry index
                                this.entryIndex.put(entry.getName(), location);
                                ++fragCount;
                            }
                        } 
                        else 
                        {
                            registry.addLocalEntry(entry);
                            // Initialize the entry index
                            this.entryIndex.put(entry.getName(), location);
                            ++fragCount;

                            if ((verbose > 1)
                                && logger.isDebugEnabled()) 
                            {
                                logger.debug(
                                    "DatabaseRegistryService: Adding entry "
                                        + entry.getName()
                                        + " of class "
                                        + entry.getClass()
                                        + " to registry "
                                        + name);
                            }
                        }
                    } 
                    catch (RegistryException e) 
                    {
                        logger.error(
                            "DatabaseRegistryService: RegistryException while adding "
                                + entry.getName()
                                + "from "
                                + location,
                            e);
                    }
                    //remove this entry from the delete list
                    toDelete.remove(entry.getName());
                }
            }

            count += fragCount;
        }

        //now delete the entries not found in any fragment
        i = toDelete.iterator();
        while (i.hasNext()) 
        {
            String entryName = (String) i.next();

            if ((verbose > 1) && logger.isDebugEnabled()) 
            {
                logger.debug(
                    "DatabaseRegistryService: removing entry " + entryName);
            }
            //TODO may  be I will  do it later 
            //it should  delete only portlets which  is coming from  database
            
            //registry.removeLocalEntry(entryName);
        }

        if ((verbose > 1) && logger.isDebugEnabled()) 
        {
            logger.debug(
                "DatabaseRegistryService: Merged "
                    + count
                    + " entries and deleted "
                    + toDelete.size()
                    + " in "
                    + name);
        }
    }

    // FileRegistry interface

    /** Refresh the state of the registry implementation. Should be called
     *   whenever the underlying fragments are modified
     */
    public void refresh() 
    {
        synchronized (watcher) 
        {
            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 ) 
    {
        try 
        {            
            RegistryFragment fragment = createFragment(file);
            //mark this fragment as changed
            fragment.setChanged(true);

            // if we get here, we successfully loaded the new fragment
            updateFragment(file, fragment);

        } 
        catch (Throwable t) 
        {
            logger.error(
                "DatabaseRegistryService: Could not unmarshal: " + file,
                t);
        }
    }

    /**
        * Read and unmarshal a fragment in memory
        * @param name the name of 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 = null;

        try 
        {
        } 
        catch (Throwable t) 
        {
            logger.error(
                "DatabaseRegistryService: Could not create fragment: " + file, t);
        } 
        finally 
        {
            try 
            {
                reader.close();
            } 
            catch (Exception e) 
            {
                logger.error(e); // At least log the exception.
            }
        }
    }
    /**
     * Marshal and save a RegistryFragment to disk
     * @param file the absolute file path storing this fragment
     */
    public void saveFragment(String file) 
    {

        /**
         * TODO I will  implement this 
         * should go  to  database
         */

    }
    /**
     * 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);
            }
        }
    }
    
    /**
     * 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);
                }
            }
        }
    }

    //class  specific implementation 
    private static List getData(String name) 
    {
        List list = null;
        try 
        {        
            DBRegistry BaseClass = (DBRegistry) baseClass.get(name);
            if (BaseClass != null) 
            {
                list = BaseClass.getXREGDataFromDb();
            }
            else
            {
                logger.warn(
                    "DatabaseRegistryService: Base class  for service " + name + " not found");
            }
        } 
        catch (Exception ex) 
        {
            logger.warn(
                "DatabaseRegistryService: Base class  for service " + name + " not found");
        }
        return list;
    }
    
    private RegistryFragment createFragment(String regName) 
    {
        RegistryFragment fragment = (RegistryFragment) fragments.get(regName);

        //Fragment can be (and sometimes is, but should not be) null
        if (fragment == null) 
        {
            fragment = new RegistryFragment();
            fragment.put(regName, new Vector());
        } 
        else 
        {
            Vector vectRegistry = (Vector) fragment.get(regName);
            if (vectRegistry == null) 
            {
                fragment.put(regName, new Vector());
            }
        }
        List entries = getData(regName);
        if (entries != null) 
        {
            for (int i = 0; i < entries.size(); i++) 
            {
                fragment.setEntry(regName, (RegistryEntry) entries.get(i));
                // mark this fragment so that it's persisted next time
                // the registry watcher is running
                fragment.setDirty(true);
            }
        }
        else
        {            
            logger.warn(
                "DatabaseRegistryService:no data fouund for service " + name );

        }
        return fragment;

    }
}