resourcestoremanager.java

很棒的web服务器源代码

   
    /**
     * Try to salvage the resource store manager state.
     * That's pretty easy and robust, it should really work well if no
     * one hacked the store directory.
     * @return A ResourceStoreState instance.
     */
    public ResourceStoreState salvageState() {
	System.err.println("*** salvaging resource manager state...");
	File state = new File(storedir, STATE_F);
	int  maxid = -1;
	FilenameFilter filter = new FilenameFilter() {
	    public boolean accept(File dir, String name) {
		return (name.startsWith("st-") && (! name.endsWith(".bak")));
	    }
	};
	for (int i = 0 ; i < SUBDIRS ; i++) {
	    File subdir = new File(storedir, Integer.toString(i));
	    if (subdir.exists()) {
		String stores[] = subdir.list(filter);
		for (int j = 0 ; j < stores.length; j++) {
		    int id = Integer.parseInt(stores[j].substring(3));
		    maxid  = Math.max(maxid, id);
		}
	    }
	}
	++maxid;
	System.err.println("*** resource store state salvaged, using: "+maxid);
	return new ResourceStoreState(maxid);
    }

    /**
     * Restore the resource whose name is given from the root NewStoreEntry.
     * @param identifier The identifier of the resource to restore.
     * @param defs Default attribute values.
     */ 
    public ResourceReference loadRootResource(String identifier,
					      Hashtable defs)
    {
	NewStoreEntry entry = (NewStoreEntry) entries.get(getRootKey());
	if (entry == null) {
	    entry = new NewStoreEntry(this, ROOT_REP, getRootKey());
	    entries.put(getRootKey(), entry);
	}
	return entry.loadResource(identifier, defs);
    }

    /**
     * Check that the key is not already in the list of references 
     * @return a boolean, true if the key is not there, false if it is
     */
    public boolean checkKey(Integer key) {
	if (entries != null) {
	    return !entries.containsKey(key);
	}
	return true;
    }

    /**
     * Lookup this resource.
     * @param sentry The resource space entry.
     * @param identifier The resource identifier.
     * @return A Resource instance, or <strong>null</strong> if either the
     *    resource doesn't exist, or it isn't loaded yet.
     */
    public ResourceReference lookupResource(SpaceEntry sentry, 
					    String identifier)
    {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null)
	    throw new RuntimeException("Unable to lookup resource ("+
				       identifier+
				       "), no StoreEntry for its space entry");
	return entry.lookupResource(identifier);
    }

    /**
     * Restore the resource whose name is given.
     * @param sentry The resource space entry.
     * @param identifier The identifier of the resource to restore.
     * @param defs Default attribute values.
     */
    public ResourceReference loadResource(SpaceEntry sentry, 
					  String identifier,
					  Hashtable defs)
    {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null) 
	    throw new RuntimeException(identifier+": Space Entry not valid");
	return entry.loadResource(identifier, defs);
    }

    /**
     * Add this resource to the StoreEntry of the space entry.
     * @param sentry The resource space entry.
     * @param resource The resource to add.
     * @param defs Default attribute values.
     */
    public ResourceReference addResource(SpaceEntry sentry,
					 Resource resource,
					 Hashtable defs)
    {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null)
	    throw new RuntimeException("Unable to add resource ("+
				       resource.getIdentifier()+
				       "), no StoreEntry for its space entry");
	return entry.addResource(resource, defs);
    }

    /**
     * Save this resource to the StoreEntry of the space entry.
     * @param sentry The resource space entry
     * @param resource The resource to save.
     */
    public void saveResource(SpaceEntry sentry,
			     Resource resource) 
    {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null)
	    throw new RuntimeException("Unable to save resource ("+
				       resource.getIdentifier()+
				       "), no StoreEntry for its space entry");
	entry.saveResource(resource);
    }

    /**
     * Mark the given resource as being modified.
     * @param sentry The resource space entry.
     * @param resource The resource to mark as modified.
     */
    public void markModified(SpaceEntry sentry,
			     Resource resource) 
    {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null)
	    throw new RuntimeException("Unable to mark resource ("+
				       resource.getIdentifier()+
				       "), no StoreEntry for its space entry");
	synchronized (resource) {
	    entry.markModified(resource);
	}
    }

    /**
     * Rename a resource in this resource space.
     * @param sentry The resource space entry.
     * @param oldid The old resorce identifier.
     * @param newid The new resorce identifier.
     */
    public void renameResource(SpaceEntry sentry,
			       String oldid,
			       String newid) 
    {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null)
	    throw new RuntimeException("Unable to rename resource ("+
				       oldid+" to "+newid+
				       "), no StoreEntry for its space entry");
	entry.renameResource(oldid, newid);
    }

    /**
     * delete this resource from the StoreEntry (and the repository).
     * @param sentry The resource space entry
     * @param resource The resource to delete.
     */
    public void deleteResource(SpaceEntry sentry,
			       Resource resource) 
    {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null)
	    throw new RuntimeException("Unable to delete resource ("+
				       resource.getIdentifier()+
				       "), no StoreEntry for its space entry");
	entry.removeResource(resource.getIdentifier());
    }

    /**
     * Delete all the children of resource indentified by its
     * space entry.
     * @param sentry The resource space entry
     */
    public void deleteChildren(SpaceEntry sentry) {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null)
	    throw new RuntimeException(
				    "Unable to delete children, no StoreEntry"+
				    " for its space entry");
	entry.deleteStore();
	entries.remove(sentry.getEntryKey());
    }

    /**
     * Save all the children of the resource indentified by its
     * spaec entry.
     * @param sentry The resource space entry
     */  
    public void saveChildren(SpaceEntry sentry) {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null)
	    throw new RuntimeException(
				      "Unable to save children, no StoreEntry"+
				      " for its space entry");
	entry.saveStore();
    }

    protected void checkMaxLoadedStore() {
	// Check to see if we have exceeded our quota:
	if (loadedStore > getMaxLoadedStore()) {
	    sweeper.sweep() ;
	}
    }

    /**
     * acquire children from an external file.
     * @param sentry The resource space entry.
     * @param repository The file used to store children.
     */
    public void acquireChildren(SpaceEntry sentry,
				File repository,
				boolean transientFlag) 
    {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null) {
	    //create it.
	    checkMaxLoadedStore();
	    entry = new NewStoreEntry(this, repository, sentry.getEntryKey());
	    entry.setTransient(transientFlag);
	    entries.put(sentry.getEntryKey(), entry);
	    // FIXME : unload index hashtable ?
	} else {
	    entry.rep = repository;
	}
    }

    /**
     * Acquire the StoreEntry of the space entry.
     * @param sentry The resource space entry.
     */
    public void acquireChildren(SpaceEntry sentry) {
	// 
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null) {
	    //create it.
	    checkMaxLoadedStore();
	    String rpath = createResourceStoreRepository();
	    File repository = new File(storedir, rpath);
	    if (repository.exists()) {
		String fpath = new String(rpath);
		String lpath = null;
		do {
		    lpath = new String(rpath);
		    rpath = createResourceStoreRepository();
		    repository = new File(storedir, rpath);
		} while (repository.exists());
		if (fpath.equals(lpath))
		    warning("repository "+fpath+" exists! using "+rpath);
		else
		    warning("repositories "+fpath+" to "+
			    lpath+" exists! using "+rpath);
	    }
	    entry = new NewStoreEntry(this, rpath, sentry.getEntryKey());
	    entries.put(sentry.getEntryKey(), entry);
	    // FIXME : unload index hashtable ?
	}
    }

    /**
     * Implementation of Status interface
     * Display statistics about usage of the resource store manager
     * @returns a String containing a fragment of HTML
     */
    public String getHTMLStatus() {
	Enumeration elements = entries.elements();
	int nb_entries = 0;
	int entries_nn = 0;
	int nb_entries_store = 0;
	int stores_nn = 0;
	int oversized = 0;
	while (elements.hasMoreElements()) {
	    int nb;
	    NewStoreEntry entry = (NewStoreEntry) elements.nextElement();
	    if (entry.references != null) {
		nb = entry.references.size();
		if (nb > 0) {
		    nb_entries += nb;
		    entries_nn++;
		}
	    }
	    if (entry.store != null) {
		ResourceStoreImpl st = (ResourceStoreImpl) entry.store;
		nb = st.resources.size();
		if (nb > 0) {
		    int ssize = st.resources.size();
		    nb_entries_store += ssize;
		    stores_nn++;
		    if ((storeSizeLimit > 0) && (ssize > storeSizeLimit)) {
			oversized++;
		    }
		}
	    }
	}
	StringBuffer sb = new StringBuffer();
	sb.append("<table border=\"1\" class=\"store\">\n"
		  + "<caption>Resource Store usage</caption>\n"
		  + "<tr><th>Loaded Stores</th>"
		  + "<th>Loaded Entries</th></tr>\n");
	sb.append("<tr><td>");
	sb.append(loadedStore);
	sb.append(" (");
	sb.append(entries.size());
	sb.append(") / ");
	sb.append(maxLoadedStore);
	if (storeSizeLimit >= 0) {
	    sb.append(" [");
	    sb.append(oversized);
	    sb.append(" > ");
	    sb.append(storeSizeLimit);
	    sb.append(" ]");
	}
	sb.append("</td><td>");
	sb.append(nb_entries);
	sb.append('(');
	sb.append(entries_nn);
	sb.append(')');
	sb.append(" / ");
	sb.append(nb_entries_store);
	sb.append('(');
	sb.append(stores_nn);
	sb.append(")</td>\n</table>");
	return sb.toString();
    }


    /**
     * Enumerate the name (ie identifiers) of the space entry children.
     * @param sentry The space entry.
     * @param all Should all resources be listed.
     * @return An enumeration, providing one element per child, which is
     * the name of the child, as a String.
     */
    public Enumeration enumerateResourceIdentifiers(SpaceEntry sentry) {
	NewStoreEntry entry = 
	    (NewStoreEntry) entries.get(sentry.getEntryKey());
	if (entry == null)
	    throw new RuntimeException(
				      "Unable to list children, no StoreEntry"+
				      " for its space entry");
	return entry.enumerateResourceIdentifiers();
    }

    /**
     * Create a new resource store manager for given store directory.
     * The resource store manager will manage the collection of stores 
     * contained in the directory, and keep track of the stores state.
     * @param storedir The store directory to manage.
     */
    public ResourceStoreManager (String server_name,
				 File storedir, 
				 String default_root_class,
				 String default_root_name,
				 String serializer_class,
				 int max_loaded_store,
				 Hashtable defs)
    {
	this(server_name, storedir, default_root_class, default_root_name,
		    serializer_class, max_loaded_store, -1, defs);
    }

    /**
     * Create a new resource store manager for given store directory.
     * The resource store manager will manage the collection of stores 
     * contained in the directory, and keep track of the stores state.
     * @param storedir The store directory to manage.
     */
    public ResourceStoreManager (String server_name,
				 File storedir, 
				 String default_root_class,
				 String default_root_name,
				 String serializer_class,
				 int max_loaded_store,
				 int store_size_limit,
				 Hashtable defs)
    {
	// Initialize the instance variables:
	this.server_name    = server_name;
	this.storedir       = storedir;
	this.entries        = new Hashtable() ;
	this.sweeper        = new StoreManagerSweeper(this) ;
	this.lru            = new AsyncLRUList();
	this.maxLoadedStore = (max_loaded_store < 10) ? 10 : max_loaded_store;
	this.storeSizeLimit = (store_size_limit < 100) ? -1 : store_size_limit;
	this.loadedStore = 0;
	
	try {
	    Class ser_class = Class.forName(serializer_class);
	    this.serializer = (Serializer) ser_class.newInstance();
	} catch (Exception ex) {
	    ex.printStackTrace();
	    throw new RuntimeException("Invalid serializer class : "+
				       serializer_class);
	}

	loadNewEntriesIndex();

	if (! checkSubDirs())
	    throw new RuntimeException("Unable to create store "+
				       "subdirectories!");

	// If not already available, create the root resource, and its
	// repository.
	getRootRepository();
	if (! root_repository.exists()) {
	    try {
		Class root_class = Class.forName(default_root_class);
		Resource root = (Resource) root_class.newInstance();
		if (defs == null)
		    defs = new Hashtable(4);
		defs.put("identifier".intern(), default_root_name);
		defs.put("key".intern(), getRootKey());
		root.initialize(defs);
		
		NewStoreEntry entry = new NewStoreEntry(this,
							ROOT_REP,
							getRootKey());
		ResourceReference rr = entry.addResource(root, defs);
		ResourceContext context = (ResourceContext) 
		    defs.get("context");
		context.setResourceReference(rr);
		entry.saveResource(root);
		entries.put(getRootKey(), entry);
		saveNewEntriesIndex();
	    } catch (InstantiationException ex) {
	    } catch (IllegalAccessException ex) {
	    } catch (ClassNotFoundException ex) {
		System.out.println(ex.getMessage());
		ex.printStackTrace();
	    }
	}
	
	// If not already available, create the resource store state object:
	File rsmstate = new File(storedir, STATE_F);
	// Restore it:
	Reader reader = null;
	try {
	    reader = new BufferedReader( new FileReader(rsmstate));
	    AttributeHolder states[] = serializer.readAttributeHolders(reader);
	    this.state = (ResourceStoreState) states[0];
	} catch (Exception ex) {
	    // Let's try to fix this:
	    this.state = salvageState();
	}
	if ( reader != null ) {
	    try { reader.close(); } catch (IOException ex) {}
	}
	//    salvage();
	//    displayIndex();
    }

}