cachemanager.java

aglet的部分源码

package com.ibm.aglets.tahiti;

/*
 * @(#)CacheManager.java
 * 
 * IBM Confidential-Restricted
 * 
 * OCO Source Materials
 * 
 * 03L7246 (c) Copyright IBM Corp. 1996, 1998
 * 
 * The source code for this program is not published or otherwise
 * divested of its trade secrets, irrespective of what has been
 * deposited with the U.S. Copyright Office.
 */

import java.io.*;
import java.util.*;
import java.net.URL;
import java.net.MalformedURLException;
import java.security.MessageDigest;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;
import java.security.PrivilegedActionException;
import com.ibm.aglet.system.AgletRuntime;
import com.ibm.awb.misc.FileUtils;
import com.ibm.awb.misc.Resource;

public class CacheManager {
	private static CacheManager _singleton = null;

	private long _cache_size = 0;

	String _pool_dir = "";
	int _pool_index = 0;

	private LinkedList _cache = null;
	private Hashtable _pool = null;

	// t    static final int _hashcode(byte[] b) {
	// t	int h = 0;
	// t	for(int i=0; i<b.length; i++) {
	// t	    h += (h * 37) + (int)b[i];
	// t	}
	// t	return h;
	// t    }

	private final class LinkedList {
		Hashtable tab;		// (key, val) = (entry, ListElem)
		ListElem first = null;
		long size;			// size in bytes.
		long maxSize;		// max size in bytes.

		private final class ListElem {
			Entry entry;
			ListElem prev;
			ListElem next;

			ListElem(Entry e) {
				entry = e;
				prev = null;
				next = null;
			}
			ListElem(Entry e, ListElem n) {
				entry = e;
				prev = null;
				next = n;
			}
			ListElem(Entry e, ListElem p, ListElem n) {
				entry = e;
				prev = p;
				next = n;
			}
			public boolean equals(Object e) {
				if (e == null) {
					return false;
				} 
				if (e instanceof Entry) {
					return entry.equals((Entry)e);
				} else if (e instanceof ListElem) {
					if (entry == null) {
						return ((((ListElem)e)).entry == null);
					} else {
						return entry.equals(((ListElem)e).entry);
					} 
				} else {
					return false;
				} 
			} 

			public int hashCode() {
				if (entry == null) {
					return 0;
				} else {
					return entry.hashCode();
				}
			} 
		}

		LinkedList(long max) {
			tab = new Hashtable();
			first = null;
			size = 0;
			maxSize = max;
		}

		void printOut() {
			int i = 0;
			ListElem elm = first;

			System.out.println("LinkedList: size=" + size + ", maxSize=" 
							   + maxSize + ", tabSize=" + tab.size());
			while (elm != null && elm.next != first) {
				System.out.println("Queue[" + i + "]=" + elm.entry);
				i++;
				elm = elm.next;
			} 
		} 

		boolean contains(Entry e) {
			return tab.contains(e);
		} 

		synchronized Entry getFirst() {
			return (first == null) ? null : first.entry;
		} 

		synchronized Entry get(Entry e) {
			ListElem elem = (ListElem)tab.get(e);

			if (elem == null) {
				return null;
			} else {
				return elem.entry;
			} 
		} 

		synchronized Entry[] putAtFirst(Entry e) {
			if (maxSize == 0 || e == null) {
				return null;
			} 
			Entry purged[] = null;
			ListElem elem = (ListElem)tab.get(e);

			if (elem != null) {

				// It's already in the queue. Move it to first posision.
				if (elem != first) {

					// (first) ... (pre) -> (elm) -> (nxt)
					// :
					// (first) -> (elm) ... (pre) -> (nxt)
					ListElem pre = elem.prev;		// must be non-null.
					ListElem nxt = elem.next;		// may be null.

					nxt.prev = pre;
					pre.next = nxt;
					elem.next = first;
					elem.prev = first.prev;
					first.prev.next = elem;
					first.prev = elem;
					first = elem;
				} 
			} else {

				// It must be new entry. Insert an element.
				if (first == null) {
					first = new ListElem(e);
					first.prev = first;
					first.next = first;
					tab.put(e, first);
					size += e.getSize();
					return purged;
				} 
				Vector pp = new Vector();

				while (size > 0 && size + e.getSize() > maxSize) {
					ListElem last = first.prev;
					Entry p = last.entry;

					pp.addElement(p);
					tab.remove(p);
					size -= p.getSize();

					if (last == first) {
						first = null;
					} else {
						first.prev = last.prev;
						last.prev.next = first;
						last.entry = null;
						last.prev = null;
						last.next = null;
					} 
				} 
				if (pp.size() > 0) {
					purged = new Entry[pp.size()];
					pp.copyInto(purged);
				} 

				// (first) -> (?) ...
				// (first) -> (elm) -> (?) ...
				if (first != null) {
					elem = new ListElem(e, first.prev, first);
					first.prev.next = elem;
					first.prev = elem;
				} else {
					elem = new ListElem(e);
					elem.prev = elem;
					elem.next = elem;
				} 
				first = elem;
				tab.put(e, elem);
				size += e.getSize();
			} 
			return purged;
		} 

		synchronized Entry remove(Entry e) {
			ListElem elem = (ListElem)tab.remove(e);

			if (elem == null) {
				return null;
			} 

			// (first) -> ... (pre) -> (elm) -> (nxt)
			ListElem pre = elem.prev;
			ListElem nxt = elem.next;

			nxt.prev = pre;
			pre.next = nxt;
			if (elem == first) {
				if (elem.next == elem) {
					first = null;
				} else {
					first = first.next;
				} 
			} 

			size -= elem.entry.getSize();
			Entry entry = elem.entry;

			elem.entry = null;
			elem.prev = null;
			elem.next = null;
			return entry;
		} 
	}

	private final class Entry implements java.io.Serializable {
		String name;
		long version;
		String filename;
		byte[] data;
		int refCount;

		Entry(String n, long v, byte[] d) {
			name = n;
			version = v;
			data = d;
			refCount = 0;
			hash = name.hashCode();		// t + _hashcode(version);
		}


		int getSize() {
			return name.length() * 2 + 8 + 

			// ((filename != null) ? filename.length() * 2 : 0) +
			4 + ((data != null) ? data.length : 0);
		} 

		void delete() {
			if (filename != null) {
				try {
					final String fn = filename;

					AccessController
						.doPrivileged(new PrivilegedExceptionAction() {
						public Object run() throws IOException {
							new File(fn).delete();
							return null;
						} 
					});
				} catch (Exception ex) {
					System.out.println("Failed to delete a cache entry: " 
									   + filename);
					ex.printStackTrace();
				} 
			} 
		} 

		/* synchronized */
		void fillInData() throws IOException {
			if (data != null) {
				return;
			} 

			debug("<Reading cache from disk...'" + name + "'");
			final File fFile = new File(filename);

			try {
				data = 
					(byte[])AccessController
						.doPrivileged(new PrivilegedExceptionAction() {
					public Object run() throws IOException {
						int i = 0;

						DataInputStream oi = 
							new DataInputStream(new FileInputStream(fFile));

						// may skip those..
						oi.readUTF();		// name
						long version = oi.readLong();

						byte[] dd = null;
						int len = oi.readInt();

						if (len >= 0) {
							dd = new byte[len];
							oi.readFully(dd);
						} 
						if (dd != null && dd.length == 0) {
							dd = null;
						} 
						return dd;
					} 
				});
			} catch (PrivilegedActionException ex) {
				Exception e = ex.getException();

				if (e instanceof IOException) {
					throw (IOException)e;
				} else {
					ex.printStackTrace();
				} 
			} catch (Exception ex) {
				ex.printStackTrace();
			} 
			debugln("done>");
		} 

		public void save() throws IOException {
			if (filename != null) {
				return;
			} 

			_pool_index++;
			filename = _pool_dir + File.separator + "c@" + _pool_index;

			debug("<Saving cache for '" + name + "'... ");
			try {
				final String fFileName = filename;
				final String fName = name;
				final long fVersion = version;
				final byte[] fData = data;

				AccessController
					.doPrivileged(new PrivilegedExceptionAction() {
					public Object run() throws IOException {
						DataOutputStream out = 
							new DataOutputStream(new FileOutputStream(fFileName));

						out.writeUTF(fName);
						out.writeLong(fVersion);
						if (fData == null) {
							out.writeInt(-1);
						} else {
							out.writeInt(fData.length);
							out.write(fData);
						} 
						out.close();
						return null;