put operations may block when the
* capacity is reached. Various implementations may have
* intrinsically hard-wired capacities, capacities that are fixed upon
* construction, or dynamically adjustable capacities.
* @see DefaultChannelCapacity
* [ Introduction to this package. ]
**/ public interface BoundedChannel extends Channel { /** * Return the maximum number of elements that can be held. * @return the capacity of this channel. **/ public int capacity(); } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/Callable.java 0000644 0001750 0001750 00000002237 10730503124 027527 0 ustar twerner twerner /* File: Callable.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 30Jun1998 dl Create public version 5Jan1999 dl Change Exception to Throwable in call signature 27Jan1999 dl Undo last change */ package org.logicalcobwebs.concurrent; /** * Interface for runnable actions that bear results and/or throw Exceptions. * This interface is designed to provide a common protocol for * result-bearing actions that can be run independently in threads, * in which case * they are ordinarily used as the bases of Runnables that set * FutureResults *
*
[ Introduction to this package. ] * @see FutureResult **/ public interface Callable { /** Perform some action that returns a result or throws an exception **/ Object call() throws Exception; } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/Channel.java 0000644 0001750 0001750 00000025534 10730503124 027405 0 ustar twerner twerner /* File: Channel.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 11Jun1998 dl Create public version 25aug1998 dl added peek */ package org.logicalcobwebs.concurrent; /** * Main interface for buffers, queues, pipes, conduits, etc. *
* A Channel represents anything that you can put items * into and take them out of. As with the Sync * interface, both * blocking (put(x), take), * and timeouts (offer(x, msecs), poll(msecs)) policies * are provided. Using a * zero timeout for offer and poll results in a pure balking policy. *
* To aid in efforts to use Channels in a more typesafe manner, * this interface extends Puttable and Takable. You can restrict * arguments of instance variables to this type as a way of * guaranteeing that producers never try to take, or consumers put. * for example: *
* class Producer implements Runnable {
* final Puttable chan;
* Producer(Puttable channel) { chan = channel; }
* public void run() {
* try {
* for(;;) { chan.put(produce()); }
* }
* catch (InterruptedException ex) {}
* }
* Object produce() { ... }
* }
*
*
* class Consumer implements Runnable {
* final Takable chan;
* Consumer(Takable channel) { chan = channel; }
* public void run() {
* try {
* for(;;) { consume(chan.take()); }
* }
* catch (InterruptedException ex) {}
* }
* void consume(Object x) { ... }
* }
*
* class Setup {
* void main() {
* Channel chan = new SomeChannelImplementation();
* Producer p = new Producer(chan);
* Consumer c = new Consumer(chan);
* new Thread(p).start();
* new Thread(c).start();
* }
* }
*
* * A given channel implementation might or might not have bounded * capacity or other insertion constraints, so in general, you cannot tell if * a given put will block. However, * Channels that are designed to * have an element capacity (and so always block when full) * should implement the * BoundedChannel * subinterface. *
* Channels may hold any kind of item. However, * insertion of null is not in general supported. Implementations * may (all currently do) throw IllegalArgumentExceptions upon attempts to * insert null. *
* By design, the Channel interface does not support any methods to determine * the current number of elements being held in the channel. * This decision reflects the fact that in * concurrent programming, such methods are so rarely useful * that including them invites misuse; at best they could * provide a snapshot of current * state, that could change immediately after being reported. * It is better practice to instead use poll and offer to try * to take and put elements without blocking. For example, * to empty out the current contents of a channel, you could write: *
* try {
* for (;;) {
* Object item = channel.poll(0);
* if (item != null)
* process(item);
* else
* break;
* }
* }
* catch(InterruptedException ex) { ... }
*
*
* However, it is possible to determine whether an item
* exists in a Channel via peek, which returns
* but does NOT remove the next item that can be taken (or null
* if there is no such item). The peek operation has a limited
* range of applicability, and must be used with care. Unless it
* is known that a given thread is the only possible consumer
* of a channel, and that no time-out-based offer operations
* are ever invoked, there is no guarantee that the item returned
* by peek will be available for a subsequent take.
*
* When appropriate, you can define an isEmpty method to
* return whether peek returns null.
*
* Also, as a compromise, even though it does not appear in interface,
* implementation classes that can readily compute the number
* of elements support a size() method. This allows careful
* use, for example in queue length monitors, appropriate to the
* particular implementation constraints and properties.
*
* All channels allow multiple producers and/or consumers. * They do not support any kind of close method * to shut down operation or indicate completion of particular * producer or consumer threads. * If you need to signal completion, one way to do it is to * create a class such as *
* class EndOfStream {
* // Application-dependent field/methods
* }
*
* And to have producers put an instance of this class into
* the channel when they are done. The consumer side can then
* check this via
* * Object x = aChannel.take(); * if (x instanceof EndOfStream) * // special actions; perhaps terminate * else * // process normally **
* In time-out based methods (poll(msecs) and offer(x, msecs), * time bounds are interpreted in * a coarse-grained, best-effort fashion. Since there is no * way in Java to escape out of a wait for a synchronized * method/block, time bounds can sometimes be exceeded when * there is a lot contention for the channel. Additionally, * some Channel semantics entail a ``point of * no return'' where, once some parts of the operation have completed, * others must follow, regardless of time bound. *
* Interruptions are in general handled as early as possible * in all methods. Normally, InterruptionExceptions are thrown * in put/take and offer(msec)/poll(msec) if interruption * is detected upon entry to the method, as well as in any * later context surrounding waits. *
* If a put returns normally, an offer * returns true, or a put or poll returns non-null, the operation * completed successfully. * In all other cases, the operation fails cleanly -- the * element is not put or taken. *
* As with Sync classes, spinloops are not directly supported, * are not particularly recommended for routine use, but are not hard * to construct. For example, here is an exponential backoff version: *
* Object backOffTake(Channel q) throws InterruptedException {
* long waitTime = 0;
* for (;;) {
* Object x = q.poll(0);
* if (x != null)
* return x;
* else {
* Thread.sleep(waitTime);
* waitTime = 3 * waitTime / 2 + 1;
* }
* }
*
* * Sample Usage. Here is a producer/consumer design * where the channel is used to hold Runnable commands representing * background tasks. *
* class Service {
* private final Channel channel = ... some Channel implementation;
*
* private void backgroundTask(int taskParam) { ... }
*
* public void action(final int arg) {
* Runnable command =
* new Runnable() {
* public void run() { backgroundTask(arg); }
* };
* try { channel.put(command) }
* catch (InterruptedException ex) {
* Thread.currentThread().interrupt(); // ignore but propagate
* }
* }
*
* public Service() {
* Runnable backgroundLoop =
* new Runnable() {
* public void run() {
* for (;;) {
* try {
* Runnable task = (Runnable)(channel.take());
* task.run();
* }
* catch (InterruptedException ex) { return; }
* }
* }
* };
* new Thread(backgroundLoop).start();
* }
* }
*
*
* [ Introduction to this package. ] * @see Sync * @see BoundedChannel **/ public interface Channel extends Puttable, Takable { /** * Place item in the channel, possibly waiting indefinitely until * it can be accepted. Channels implementing the BoundedChannel * subinterface are generally guaranteed to block on puts upon * reaching capacity, but other implementations may or may not block. * @param item the element to be inserted. Should be non-null. * @exception InterruptedException if the current thread has * been interrupted at a point at which interruption * is detected, in which case the element is guaranteed not * to be inserted. Otherwise, on normal return, the element is guaranteed * to have been inserted. **/ public void put(Object item) throws InterruptedException; /** * Place item in channel only if it can be accepted within * msecs milliseconds. The time bound is interpreted in * a coarse-grained, best-effort fashion. * @param item the element to be inserted. Should be non-null. * @param msecs the number of milliseconds to wait. If less than * or equal to zero, the method does not perform any timed waits, * but might still require * access to a synchronization lock, which can impose unbounded * delay if there is a lot of contention for the channel. * @return true if accepted, else false * @exception InterruptedException if the current thread has * been interrupted at a point at which interruption * is detected, in which case the element is guaranteed not * to be inserted (i.e., is equivalent to a false return). **/ public boolean offer(Object item, long msecs) throws InterruptedException; /** * Return and remove an item from channel, * possibly waiting indefinitely until * such an item exists. * @return some item from the channel. Different implementations * may guarantee various properties (such as FIFO) about that item * @exception InterruptedException if the current thread has * been interrupted at a point at which interruption * is detected, in which case state of the channel is unchanged. * **/ public Object take() throws InterruptedException; /** * Return and remove an item from channel only if one is available within * msecs milliseconds. The time bound is interpreted in a coarse * grained, best-effort fashion. * @param msecs the number of milliseconds to wait. If less than * or equal to zero, the operation does not perform any timed waits, * but might still require * access to a synchronization lock, which can impose unbounded * delay if there is a lot of contention for the channel. * @return some item, or null if the channel is empty. * @exception InterruptedException if the current thread has * been interrupted at a point at which interruption * is detected, in which case state of the channel is unchanged * (i.e., equivalent to a null return). **/ public Object poll(long msecs) throws InterruptedException; /** * Return, but do not remove object at head of Channel, * or null if it is empty. **/ public Object peek(); } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/DefaultChannelCapacity.java 0000644 0001750 0001750 00000003433 10730503124 032362 0 ustar twerner twerner /* File: DefaultChannelCapacity.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 11Jun1998 dl Create public version */ package org.logicalcobwebs.concurrent; /** * A utility class to set the default capacity of * BoundedChannel * implementations that otherwise require a capacity argument * @see BoundedChannel * [ Introduction to this package. ]
**/
public class DefaultChannelCapacity {
/** The initial value of the default capacity is 1024 **/
public static final int INITIAL_DEFAULT_CAPACITY = 1024;
/** the current default capacity **/
private static final SynchronizedInt defaultCapacity_ =
new SynchronizedInt(INITIAL_DEFAULT_CAPACITY);
/**
* Set the default capacity used in
* default (no-argument) constructor for BoundedChannels
* that otherwise require a capacity argument.
* @exception IllegalArgumentException if capacity less or equal to zero
*/
public static void set(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException();
defaultCapacity_.set(capacity);
}
/**
* Get the default capacity used in
* default (no-argument) constructor for BoundedChannels
* that otherwise require a capacity argument.
* Initial value is INITIAL_DEFAULT_CAPACITY
* @see #INITIAL_DEFAULT_CAPACITY
*/
public static int get() {
return defaultCapacity_.get();
}
}
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/Executor.java 0000644 0001750 0001750 00000005121 10730503124 027621 0 ustar twerner twerner /*
File: Executor.java
Originally written by Doug Lea and released into the public domain.
This may be used for any purposes whatsoever without acknowledgment.
Thanks for the assistance and support of Sun Microsystems Labs,
and everyone contributing, testing, and using this code.
History:
Date Who What
19Jun1998 dl Create public version
*/
package org.logicalcobwebs.concurrent;
/**
* Interface for objects that execute Runnables,
* as well as various objects that can be wrapped
* as Runnables.
* The main reason to use Executor throughout a program or
* subsystem is to provide flexibility: You can easily
* change from using thread-per-task to using pools or
* queuing, without needing to change most of your code that
* generates tasks.
*
* The general intent is that execution be asynchronous,
* or at least independent of the caller. For example,
* one of the simplest implementations of execute
* (as performed in ThreadedExecutor)
* is new Thread(command).start();.
* However, this interface allows implementations that instead
* employ queueing or pooling, or perform additional
* bookkeeping.
*
* *
[ Introduction to this package. ] **/ public interface Executor { /** * Execute the given command. This method is guaranteed * only to arrange for execution, that may actually * occur sometime later; for example in a new * thread. However, in fully generic use, callers * should be prepared for execution to occur in * any fashion at all, including immediate direct * execution. *
* The method is defined not to throw * any checked exceptions during execution of the command. Generally, * any problems encountered will be asynchronous and * so must be dealt with via callbacks or error handler * objects. If necessary, any context-dependent * catastrophic errors encountered during * actions that arrange for execution could be accompanied * by throwing context-dependent unchecked exceptions. *
* However, the method does throw InterruptedException: * It will fail to arrange for execution * if the current thread is currently interrupted. * Further, the general contract of the method is to avoid, * suppress, or abort execution if interruption is detected * in any controllable context surrounding execution. **/ public void execute(Runnable command) throws InterruptedException; } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/FJTask.java 0000644 0001750 0001750 00000046133 10730503124 027155 0 ustar twerner twerner /* File: Task.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 7Jan1999 dl first release 14jan1999 dl simplify start() semantics; improve documentation 18Jan1999 dl Eliminate useless time-based waits. 7Mar1999 dl Add reset method, add array-based composite operations 27Apr1999 dl Rename */ package org.logicalcobwebs.concurrent; /** * Abstract base class for Fork/Join Tasks. * *
* FJTasks are lightweight, stripped-down analogs of Threads. * Many FJTasks share the same pool of Java threads. This is * supported by the FJTaskRunnerGroup and FJTaskRunner classes, that * mainly contain * methods called only internally by FJTasks. * FJTasks support versions of the most common methods found in class Thread, * including start(), yield() and join(). However, they * don't support priorities, ThreadGroups or other bookkeeping * or control methods of class Thread. *
* FJTasks should normally be defined by subclassing and adding a run() method.
* Alternatively, static inner class Wrap(Runnable r)
* can be used to
* wrap an existing Runnable object in a FJTask.
*
* FJTaskRunnerGroup.execute(FJTask) can be used to
* initiate a FJTask from a non-FJTask thread.
* And FJTaskRunnerGroup.invoke(FJTask) can be used to initiate
* a FJTask and then wait for it to complete before returning.
* These are the only entry-points from normal threads to FJTasks.
* Most FJTask methods themselves may only be called from within running FJTasks.
* They throw ClassCastExceptions if they are not,
* reflecting the fact that these methods
* can only be executed using FJTaskRunner threads, not generic
* java.lang.Threads.
*
* There are three different ways to run a FJTask, * with different scheduling semantics: *
* The main economies of FJTasks stem from the fact that * FJTasks do not support blocking operations of any kind. * FJTasks should just run to completion without * issuing waits or performing blocking IO. * There are several styles for creating the run methods that * execute as tasks, including * event-style methods, and pure computational methods. * Generally, the best kinds of FJTasks are those that in turn * generate other FJTasks. *
* There is nothing actually * preventing you from blocking within a FJTask, and very short waits/blocks are * completely well behaved. But FJTasks are not designed * to support arbitrary synchronization * since there is no way to suspend and resume individual tasks * once they have begun executing. FJTasks should also be finite * in duration -- they should not contain infinite loops. * FJTasks that might need to perform a blocking * action, or hold locks for extended periods, or * loop forever can instead create normal * java Thread objects that will do so. FJTasks are just not * designed to support these things. * FJTasks may however yield() control to allow their FJTaskRunner threads * to run other tasks, * and may wait for other dependent tasks via join(). These * are the only coordination mechanisms supported by FJTasks. *
* FJTasks, and the FJTaskRunners that execute them are not * intrinsically robust with respect to exceptions. * A FJTask that aborts via an exception does not automatically * have its completion flag (isDone) set. * As with ordinary Threads, an uncaught exception will normally cause * its FJTaskRunner thread to die, which in turn may sometimes * cause other computations being performed to hang or abort. * You can of course * do better by trapping exceptions inside the run methods of FJTasks. *
* The overhead differences between FJTasks and Threads are substantial, * especially when using fork() or coInvoke(). * FJTasks can be two or three orders of magnitude faster than Threads, * at least when run on JVMs with high-performance garbage collection * (every FJTask quickly becomes garbage) and good native thread support. *
* Given these overhead savings, you might be tempted to use FJTasks for * everything you would use a normal Thread to do. Don't. Java Threads * remain better for general purpose thread-based programming. Remember * that FJTasks cannot be used for designs involving arbitrary blocking * synchronization or I/O. Extending FJTasks to support such capabilities * would amount to re-inventing the Thread class, and would make them * less optimal in the contexts that they were designed for. *
[ Introduction to this package. ] *
* @see FJTaskRunner * @see FJTaskRunnerGroup **/ public abstract class FJTask implements Runnable { /** * The only status information associated with FJTasks is whether * the they are considered to have completed. * It is set true automatically within * FJTaskRunner methods upon completion * of the run method, or manually via cancel. **/ private volatile boolean done; // = false; /** * Return the FJTaskRunner thread running the current FJTask. * Most FJTask methods are just relays to their current * FJTaskRunners, that perform the indicated actions. * @exception ClassCastException if caller thread is not a * running FJTask. **/ public static FJTaskRunner getFJTaskRunner() { return (FJTaskRunner) (Thread.currentThread()); } /** * Return the FJTaskRunnerGroup of the thread running the current FJTask. * @exception ClassCastException if caller thread is not a * running FJTask. **/ public static FJTaskRunnerGroup getFJTaskRunnerGroup() { return getFJTaskRunner().getGroup(); } /** * Return true if current task has terminated or been cancelled. * The method is a simple analog of the Thread.isAlive() * method. However, it reports true only when the task has terminated * or has been cancelled. It does not distinguish these two cases. * And there is no way to determine whether a FJTask has been started * or is currently executing. **/ public final boolean isDone() { return done; } /** * Indicate termination. Intended only to be called by FJTaskRunner. * FJTasks themselves should use (non-final) method * cancel() to suppress execution. **/ protected final void setDone() { done = true; } /** * Set the termination status of this task. This simple-minded * analog of Thread.interrupt * causes the task not to execute if it has not already been started. * Cancelling a running FJTask * has no effect unless the run method itself uses isDone() * to probe cancellation and take appropriate action. * Individual run() methods may sense status and * act accordingly, normally by returning early. **/ public void cancel() { setDone(); } /** * Clear the termination status of this task. * This method is intended to be used * only as a means to allow task objects to be recycled. It should * be called only when you are sure that the previous * execution of this task has terminated and, if applicable, has * been joined by all other waiting tasks. Usage in any other * context is a very bad idea. **/ public void reset() { done = false; } /** * Execute this task. This method merely places the task in a * group-wide scheduling queue. * It will be run * the next time any TaskRunner thread is otherwise idle. * This scheduling maintains FIFO ordering of started tasks * with respect to * the group of worker threads. * @exception ClassCastException if caller thread is not * running in a FJTaskRunner thread. **/ public void start() { getFJTaskRunnerGroup().executeTask(this); } /** * Arrange for execution of a strictly dependent task. * The task that will be executed in * procedure-call-like LIFO order if executed by the * same worker thread, but is FIFO with respect to other tasks * forked by this thread when taken by other worker threads. * That is, earlier-forked * tasks are preferred to later-forked tasks by other idle workers. *
* Fork() is noticeably * faster than start(). However, it may only * be used for strictly dependent tasks -- generally, those that * could logically be issued as straight method calls without * changing the logic of the program. * The method is optimized for use in parallel fork/join designs * in which the thread that issues one or more forks * cannot continue until at least some of the forked * threads terminate and are joined. * @exception ClassCastException if caller thread is not * running in a FJTaskRunner thread. **/ public void fork() { getFJTaskRunner().push(this); } /** * Allow the current underlying FJTaskRunner thread to process other tasks. *
* Spinloops based on yield() are well behaved so long * as the event or condition being waited for is produced via another * FJTask. Additionally, you must never hold a lock * while performing a yield or join. (This is because * multiple FJTasks can be run by the same Thread during * a yield. Since java locks are held per-thread, the lock would not * maintain the conceptual exclusion you have in mind.) *
* Otherwise, spinloops using
* yield are the main construction of choice when a task must wait
* for a condition that it is sure will eventually occur because it
* is being produced by some other FJTask. The most common
* such condition is built-in: join() repeatedly yields until a task
* has terminated after producing some needed results. You can also
* use yield to wait for callbacks from other FJTasks, to wait for
* status flags to be set, and so on. However, in all these cases,
* you should be confident that the condition being waited for will
* occur, essentially always because it is produced by
* a FJTask generated by the current task, or one of its subtasks.
*
* @exception ClassCastException if caller thread is not
* running in a FJTaskRunner thread.
**/
public static void yield() {
getFJTaskRunner().taskYield();
}
/**
* Yield until this task isDone.
* Equivalent to while(!isDone()) yield();
* @exception ClassCastException if caller thread is not
* running in a FJTaskRunner thread.
**/
public void join() {
getFJTaskRunner().taskJoin(this);
}
/**
* Immediately execute task t by calling its run method. Has no
* effect if t has already been run or has been cancelled.
* It is equivalent to calling t.run except that it
* deals with completion status, so should always be used
* instead of directly calling run.
* The method can be useful
* when a computation has been packaged as a FJTask, but you just need to
* directly execute its body from within some other task.
**/
public static void invoke(FJTask t) {
if (!t.isDone()) {
t.run();
t.setDone();
}
}
/**
* Fork both tasks and then wait for their completion. It behaves as:
*
* task1.fork(); task2.fork(); task2.join(); task1.join();
*
* As a simple classic example, here is
* a class that computes the Fibonacci function:
*
* public class Fib extends FJTask {
*
* // Computes fibonacci(n) = fibonacci(n-1) + fibonacci(n-2); for n> 1
* // fibonacci(0) = 0;
* // fibonacci(1) = 1.
*
* // Value to compute fibonacci function for.
* // It is replaced with the answer when computed.
* private volatile int number;
*
* public Fib(int n) { number = n; }
*
* public int getAnswer() {
* if (!isDone()) throw new Error("Not yet computed");
* return number;
* }
*
* public void run() {
* int n = number;
* if (n > 1) {
* Fib f1 = new Fib(n - 1);
* Fib f2 = new Fib(n - 2);
*
* coInvoke(f1, f2); // run these in parallel
*
* // we know f1 and f2 are computed, so just directly access numbers
* number = f1.number + f2.number;
* }
* }
*
* public static void main(String[] args) { // sample driver
* try {
* int groupSize = 2; // 2 worker threads
* int num = 35; // compute fib(35)
* FJTaskRunnerGroup group = new FJTaskRunnerGroup(groupSize);
* Fib f = new Fib(num);
* group.invoke(f);
* int result = f.getAnswer();
* System.out.println(" Answer: " + result);
* }
* catch (InterruptedException ex) {
* System.out.println("Interrupted");
* }
* }
* }
*
*
* @exception ClassCastException if caller thread is not
* running in a FJTaskRunner thread.
**/
public static void coInvoke(FJTask task1, FJTask task2) {
getFJTaskRunner().coInvoke(task1, task2);
}
/**
* Fork all tasks in array, and await their completion.
* Behaviorally equivalent to:
*
* for (int i = 0; i < tasks.length; ++i) tasks[i].fork();
* for (int i = 0; i < tasks.length; ++i) tasks[i].join();
*
**/
public static void coInvoke(FJTask[] tasks) {
getFJTaskRunner().coInvoke(tasks);
}
/**
* A FJTask that holds a Runnable r, and calls r.run when executed.
* The class is a simple utilty to allow arbitrary Runnables
* to be used as FJTasks.
**/
public static class Wrap extends FJTask {
protected final Runnable runnable;
public Wrap(Runnable r) {
runnable = r;
}
public void run() {
runnable.run();
}
}
/**
* A new Seq, when executed,
* invokes each task provided in the constructor, in order.
* The class is a simple utility
* that makes it easier to create composite FJTasks.
**/
public static class Seq extends FJTask {
protected final FJTask[] tasks;
/**
* Construct a Seq that, when executed, will process each of the
* tasks in the tasks array in order
**/
public Seq(FJTask[] tasks) {
this.tasks = tasks;
}
/**
* Two-task constructor, for compatibility with previous release.
**/
public Seq(FJTask task1, FJTask task2) {
this.tasks = new FJTask[]{task1, task2};
}
public void run() {
for (int i = 0; i < tasks.length; ++i) FJTask.invoke(tasks[i]);
}
}
/**
* Construct and return a FJTask object that, when executed, will
* invoke the tasks in the tasks array in array order
**/
public static FJTask seq(FJTask[] tasks) {
return new Seq(tasks);
}
/**
* A new Par, when executed,
* runs the tasks provided in the constructor in parallel using
* coInvoke(tasks).
* The class is a simple utility
* that makes it easier to create composite FJTasks.
**/
public static class Par extends FJTask {
protected final FJTask[] tasks;
/**
* Construct a Seq that, when executed, will process each of the
* tasks in the tasks array in parallel
**/
public Par(FJTask[] tasks) {
this.tasks = tasks;
}
/**
* Two-task constructor, for compatibility with previous release.
**/
public Par(FJTask task1, FJTask task2) {
this.tasks = new FJTask[]{task1, task2};
}
public void run() {
FJTask.coInvoke(tasks);
}
}
/**
* Construct and return a FJTask object that, when executed, will
* invoke the tasks in the tasks array in parallel using coInvoke
**/
public static FJTask par(FJTask[] tasks) {
return new Par(tasks);
}
/**
* A new Seq2(task1, task2), when executed,
* invokes task1 and then task2, in order.
* The class is a simple utility
* that makes it easier to create composite Tasks.
**/
public static class Seq2 extends FJTask {
protected final FJTask fst;
protected final FJTask snd;
public Seq2(FJTask task1, FJTask task2) {
fst = task1;
snd = task2;
}
public void run() {
FJTask.invoke(fst);
FJTask.invoke(snd);
}
}
/**
* Construct and return a FJTask object that, when executed, will
* invoke task1 and task2, in order
**/
public static FJTask seq(FJTask task1, FJTask task2) {
return new Seq2(task1, task2);
}
/**
* A new Par(task1, task2), when executed,
* runs task1 and task2 in parallel using coInvoke(task1, task2).
* The class is a simple utility
* that makes it easier to create composite Tasks.
**/
public static class Par2 extends FJTask {
protected final FJTask fst;
protected final FJTask snd;
public Par2(FJTask task1, FJTask task2) {
fst = task1;
snd = task2;
}
public void run() {
FJTask.coInvoke(fst, snd);
}
}
/**
* Construct and return a FJTask object that, when executed, will
* invoke task1 and task2, in parallel
**/
public static FJTask par(FJTask task1, FJTask task2) {
return new Par2(task1, task2);
}
}
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/FJTaskRunner.java 0000644 0001750 0001750 00000075424 10730503124 030354 0 ustar twerner twerner /*
File: FJTaskRunner.java
Originally written by Doug Lea and released into the public domain.
This may be used for any purposes whatsoever without acknowledgment.
Thanks for the assistance and support of Sun Microsystems Labs,
and everyone contributing, testing, and using this code.
History:
Date Who What
7Jan1999 dl First public release
13Jan1999 dl correct a stat counter update;
ensure inactive status on run termination;
misc minor cleaup
14Jan1999 dl Use random starting point in scan;
variable renamings.
18Jan1999 dl Runloop allowed to die on task exception;
remove useless timed join
22Jan1999 dl Rework scan to allow use of priorities.
6Feb1999 dl Documentation updates.
7Mar1999 dl Add array-based coInvoke
31Mar1999 dl Revise scan to remove need for NullTasks
27Apr1999 dl Renamed
23oct1999 dl Earlier detect of interrupt in scanWhileIdling
24nov1999 dl Now works on JVMs that do not properly
implement read-after-write of 2 volatiles.
*/
package org.logicalcobwebs.concurrent;
import java.util.Random;
/**
* Specialized Thread subclass for running FJTasks.
* * Each FJTaskRunner keeps FJTasks in a double-ended queue (DEQ). * Double-ended queues support stack-based operations * push and pop, as well as queue-based operations put and take. * Normally, threads run their own tasks. But they * may also steal tasks from each others DEQs. *
* The algorithms are minor variants of those used * in Cilk and * Hood, and * to a lesser extent * Filaments, * but are adapted to work in Java. *
* The two most important capabilities are: *
* Push task onto DEQ **
* If DEQ is not empty,
* Pop a task and run it.
* Else if any other DEQ is not empty,
* Take ("steal") a task from it and run it.
* Else if the entry queue for our group is not empty,
* Take a task from it and run it.
* Else if current thread is otherwise idling
* If all threads are idling
* Wait for a task to be put on group entry queue
* Else
* Yield or Sleep for a while, and then retry
*
* * Implementations of the underlying representations and operations * are geared for use on JVMs operating on multiple CPUs (although * they should of course work fine on single CPUs as well). *
* A possible snapshot of a FJTaskRunner's DEQ is: *
* 0 1 2 3 4 5 6 ... * +-----+-----+-----+-----+-----+-----+-----+-- * | | t | t | t | t | | | ... deq array * +-----+-----+-----+-----+-----+-----+-----+-- * ^ ^ * base top * (incremented (incremented * on take, on push * decremented decremented * on put) on pop) **
* FJTasks are held in elements of the DEQ.
* They are maintained in a bounded array that
* works similarly to a circular bounded buffer. To ensure
* visibility of stolen FJTasks across threads, the array elements
* must be volatile.
* Using volatile rather than synchronizing suffices here since
* each task accessed by a thread is either one that it
* created or one that has never seen before. Thus we cannot
* encounter any staleness problems executing run methods,
* although FJTask programmers must be still sure to either synch or use
* volatile for shared data within their run methods.
*
* However, since there is no way * to declare an array of volatiles in Java, the DEQ elements actually * hold VolatileTaskRef objects, each of which in turn holds a * volatile reference to a FJTask. * Even with the double-indirection overhead of * volatile refs, using an array for the DEQ works out * better than linking them since fewer shared * memory locations need to be * touched or modified by the threads while using the DEQ. * Further, the double indirection may alleviate cache-line * sharing effects (which cannot otherwise be directly dealt with in Java). *
* The indices for the base and top of the DEQ
* are declared as volatile. The main contention point with
* multiple FJTaskRunner threads occurs when one thread is trying
* to pop its own stack while another is trying to steal from it.
* This is handled via a specialization of Dekker's algorithm,
* in which the popping thread pre-decrements top,
* and then checks it against base.
* To be conservative in the face of JVMs that only partially
* honor the specification for volatile, the pop proceeds
* without synchronization only if there are apparently enough
* items for both a simultaneous pop and take to succeed.
* It otherwise enters a
* synchronized lock to check if the DEQ is actually empty,
* if so failing. The stealing thread
* does almost the opposite, but is set up to be less likely
* to win in cases of contention: Steals always run under synchronized
* locks in order to avoid conflicts with other ongoing steals.
* They pre-increment base, and then check against
* top. They back out (resetting the base index
* and failing to steal) if the
* DEQ is empty or is about to become empty by an ongoing pop.
*
* A push operation can normally run concurrently with a steal. * A push enters a synch lock only if the DEQ appears full so must * either be resized or have indices adjusted due to wrap-around * of the bounded DEQ. The put operation always requires synchronization. *
* When a FJTaskRunner thread has no tasks of its own to run, * it tries to be a good citizen. * Threads run at lower priority while scanning for work. *
* If the task is currently waiting * via yield, the thread alternates scans (starting at a randomly * chosen victim) with Thread.yields. This is * well-behaved so long as the JVM handles Thread.yield in a * sensible fashion. (It need not. Thread.yield is so underspecified * that it is legal for a JVM to treat it as a no-op.) This also * keeps things well-behaved even if we are running on a uniprocessor * JVM using a simple cooperative threading model. *
* If a thread needing work is * is otherwise idle (which occurs only in the main runloop), and * there are no available tasks to steal or poll, it * instead enters into a sleep-based (actually timed wait(msec)) * phase in which it progressively sleeps for longer durations * (up to a maximum of FJTaskRunnerGroup.MAX_SLEEP_TIME, * currently 100ms) between scans. * If all threads in the group * are idling, they further progress to a hard wait phase, suspending * until a new task is entered into the FJTaskRunnerGroup entry queue. * A sleeping FJTaskRunner thread may be awakened by a new * task being put into the group entry queue or by another FJTaskRunner * becoming active, but not merely by some DEQ becoming non-empty. * Thus the MAX_SLEEP_TIME provides a bound for sleep durations * in cases where all but one worker thread start sleeping * even though there will eventually be work produced * by a thread that is taking a long time to place tasks in DEQ. * These sleep mechanics are handled in the FJTaskRunnerGroup class. *
* Composite operations such as taskJoin include heavy * manual inlining of the most time-critical operations * (mainly FJTask.invoke). * This opens up a few opportunities for further hand-optimizations. * Until Java compilers get a lot smarter, these tweaks * improve performance significantly enough for task-intensive * programs to be worth the poorer maintainability and code duplication. *
* Because they are so fragile and performance-sensitive, nearly * all methods are declared as final. However, nearly all fields * and methods are also declared as protected, so it is possible, * with much care, to extend functionality in subclasses. (Normally * you would also need to subclass FJTaskRunnerGroup.) *
* None of the normal java.lang.Thread class methods should ever be called * on FJTaskRunners. For this reason, it might have been nicer to * declare FJTaskRunner as a Runnable to run within a Thread. However, * this would have complicated many minor logistics. And since * no FJTaskRunner methods should normally be called from outside the * FJTask and FJTaskRunnerGroup classes either, this decision doesn't impact * usage. *
* You might think that layering this kind of framework on top of * Java threads, which are already several levels removed from raw CPU * scheduling on most systems, would lead to very poor performance. * But on the platforms * tested, the performance is quite good. *
[ Introduction to this package. ]
* @see FJTask
* @see FJTaskRunnerGroup
**/
public class FJTaskRunner extends Thread {
/** The group of which this FJTaskRunner is a member **/
protected final FJTaskRunnerGroup group;
/**
* Constructor called only during FJTaskRunnerGroup initialization
**/
protected FJTaskRunner(FJTaskRunnerGroup g) {
group = g;
victimRNG = new Random(System.identityHashCode(this));
runPriority = getPriority();
setDaemon(true);
}
/**
* Return the FJTaskRunnerGroup of which this thread is a member
**/
protected final FJTaskRunnerGroup getGroup() {
return group;
}
/* ------------ DEQ Representation ------------------- */
/**
* FJTasks are held in an array-based DEQ with INITIAL_CAPACITY
* elements. The DEQ is grown if necessary, but default value is
* normally much more than sufficient unless there are
* user programming errors or questionable operations generating
* large numbers of Tasks without running them.
* Capacities must be a power of two.
**/
protected static final int INITIAL_CAPACITY = 4096;
/**
* The maximum supported DEQ capacity.
* When exceeded, FJTaskRunner operations throw Errors
**/
protected static final int MAX_CAPACITY = 1 << 30;
/**
* An object holding a single volatile reference to a FJTask.
**/
protected final static class VolatileTaskRef {
/** The reference **/
protected volatile FJTask ref;
/** Set the reference **/
protected final void put(FJTask r) {
ref = r;
}
/** Return the reference **/
protected final FJTask get() {
return ref;
}
/** Return the reference and clear it **/
protected final FJTask take() {
FJTask r = ref;
ref = null;
return r;
}
/**
* Initialization utility for constructing arrays.
* Make an array of given capacity and fill it with
* VolatileTaskRefs.
**/
protected static VolatileTaskRef[] newArray(int cap) {
VolatileTaskRef[] a = new VolatileTaskRef[cap];
for (int k = 0; k < cap; k++) a[k] = new VolatileTaskRef();
return a;
}
}
/**
* The DEQ array.
**/
protected VolatileTaskRef[] deq = VolatileTaskRef.newArray(INITIAL_CAPACITY);
/** Current size of the task DEQ **/
protected int deqSize() {
return deq.length;
}
/**
* Current top of DEQ. Generally acts just like a stack pointer in an
* array-based stack, except that it circularly wraps around the
* array, as in an array-based queue. The value is NOT
* always kept within 0 ... deq.length though.
* The current top element is always at top & (deq.length-1).
* To avoid integer overflow, top is reset down
* within bounds whenever it is noticed to be out out bounds;
* at worst when it is at 2 * deq.length.
**/
protected volatile int top = 0;
/**
* Current base of DEQ. Acts like a take-pointer in an
* array-based bounded queue. Same bounds and usage as top.
**/
protected volatile int base = 0;
/**
* An extra object to synchronize on in order to
* achieve a memory barrier.
**/
protected final Object barrier = new Object();
/* ------------ Other BookKeeping ------------------- */
/**
* Record whether current thread may be processing a task
* (i.e., has been started and is not in an idle wait).
* Accessed, under synch, ONLY by FJTaskRunnerGroup, but the field is
* stored here for simplicity.
**/
protected boolean active = false;
/** Random starting point generator for scan() **/
protected final Random victimRNG;
/** Priority to use while scanning for work **/
protected int scanPriority = FJTaskRunnerGroup.DEFAULT_SCAN_PRIORITY;
/** Priority to use while running tasks **/
protected int runPriority;
/**
* Set the priority to use while scanning.
* We do not bother synchronizing access, since
* by the time the value is needed, both this FJTaskRunner
* and its FJTaskRunnerGroup will
* necessarily have performed enough synchronization
* to avoid staleness problems of any consequence.
**/
protected void setScanPriority(int pri) {
scanPriority = pri;
}
/**
* Set the priority to use while running tasks.
* Same usage and rationale as setScanPriority.
**/
protected void setRunPriority(int pri) {
runPriority = pri;
}
/**
* Compile-time constant for statistics gathering.
* Even when set, reported values may not be accurate
* since all are read and written without synchronization.
**/
static final boolean COLLECT_STATS = true;
// static final boolean COLLECT_STATS = false;
// for stat collection
/** Total number of tasks run **/
protected int runs = 0;
/** Total number of queues scanned for work **/
protected int scans = 0;
/** Total number of tasks obtained via scan **/
protected int steals = 0;
/* ------------ DEQ operations ------------------- */
/**
* Push a task onto DEQ.
* Called ONLY by current thread.
**/
protected final void push(final FJTask r) {
int t = top;
/*
This test catches both overflows and index wraps. It doesn't
really matter if base value is in the midst of changing in take.
As long as deq length is < 2^30, we are guaranteed to catch wrap in
time since base can only be incremented at most length times
between pushes (or puts).
*/
if (t < (base & (deq.length - 1)) + deq.length) {
deq[t & (deq.length - 1)].put(r);
top = t + 1;
} else // isolate slow case to increase chances push is inlined
slowPush(r); // check overflow and retry
}
/**
* Handle slow case for push
**/
protected synchronized void slowPush(final FJTask r) {
checkOverflow();
push(r); // just recurse -- this one is sure to succeed.
}
/**
* Enqueue task at base of DEQ.
* Called ONLY by current thread.
* This method is currently not called from class FJTask. It could be used
* as a faster way to do FJTask.start, but most users would
* find the semantics too confusing and unpredictable.
**/
protected final synchronized void put(final FJTask r) {
for (; ;) {
int b = base - 1;
if (top < b + deq.length) {
int newBase = b & (deq.length - 1);
deq[newBase].put(r);
base = newBase;
if (b != newBase) { // Adjust for index underflow
int newTop = top & (deq.length - 1);
if (newTop < newBase) newTop += deq.length;
top = newTop;
}
return;
} else {
checkOverflow();
// ... and retry
}
}
}
/**
* Return a popped task, or null if DEQ is empty.
* Called ONLY by current thread.
*
* This is not usually called directly but is * instead inlined in callers. This version differs from the * cilk algorithm in that pop does not fully back down and * retry in the case of potential conflict with take. It simply * rechecks under synch lock. This gives a preference * for threads to run their own tasks, which seems to * reduce flailing a bit when there are few tasks to run. **/ protected final FJTask pop() { /* Decrement top, to force a contending take to back down. */ int t = --top; /* To avoid problems with JVMs that do not properly implement read-after-write of a pair of volatiles, we conservatively grab without lock only if the DEQ appears to have at least two elements, thus guaranteeing that both a pop and take will succeed, even if the pre-increment in take is not seen by current thread. Otherwise we recheck under synch. */ if (base + 1 < t) return deq[t & (deq.length - 1)].take(); else return confirmPop(t); } /** * Check under synch lock if DEQ is really empty when doing pop. * Return task if not empty, else null. **/ protected final synchronized FJTask confirmPop(int provisionalTop) { if (base <= provisionalTop) return deq[provisionalTop & (deq.length - 1)].take(); else { // was empty /* Reset DEQ indices to zero whenever it is empty. This both avoids unnecessary calls to checkOverflow in push, and helps keep the DEQ from accumulating garbage */ top = base = 0; return null; } } /** * Take a task from the base of the DEQ. * Always called by other threads via scan() **/ protected final synchronized FJTask take() { /* Increment base in order to suppress a contending pop */ int b = base++; if (b < top) return confirmTake(b); else { // back out base = b; return null; } } /** * double-check a potential take **/ protected FJTask confirmTake(int oldBase) { /* Use a second (guaranteed uncontended) synch to serve as a barrier in case JVM does not properly process read-after-write of 2 volatiles */ synchronized (barrier) { if (oldBase < top) { /* We cannot call deq[oldBase].take here because of possible races when nulling out versus concurrent push operations. Resulting accumulated garbage is swept out periodically in checkOverflow, or more typically, just by keeping indices zero-based when found to be empty in pop, which keeps active region small and constantly overwritten. */ return deq[oldBase & (deq.length - 1)].get(); } else { base = oldBase; return null; } } } /** * Adjust top and base, and grow DEQ if necessary. * Called only while DEQ synch lock being held. * We don't expect this to be called very often. In most * programs using FJTasks, it is never called. **/ protected void checkOverflow() { int t = top; int b = base; if (t - b < deq.length - 1) { // check if just need an index reset int newBase = b & (deq.length - 1); int newTop = top & (deq.length - 1); if (newTop < newBase) newTop += deq.length; top = newTop; base = newBase; /* Null out refs to stolen tasks. This is the only time we can safely do it. */ int i = newBase; while (i != newTop && deq[i].ref != null) { deq[i].ref = null; i = (i - 1) & (deq.length - 1); } } else { // grow by doubling array int newTop = t - b; int oldcap = deq.length; int newcap = oldcap * 2; if (newcap >= MAX_CAPACITY) throw new Error("FJTask queue maximum capacity exceeded"); VolatileTaskRef[] newdeq = new VolatileTaskRef[newcap]; // copy in bottom half of new deq with refs from old deq for (int j = 0; j < oldcap; ++j) newdeq[j] = deq[b++ & (oldcap - 1)]; // fill top half of new deq with new refs for (int j = oldcap; j < newcap; ++j) newdeq[j] = new VolatileTaskRef(); deq = newdeq; base = 0; top = newTop; } } /* ------------ Scheduling ------------------- */ /** * Do all but the pop() part of yield or join, by * traversing all DEQs in our group looking for a task to * steal. If none, it checks the entry queue. *
* Since there are no good, portable alternatives, * we rely here on a mixture of Thread.yield and priorities * to reduce wasted spinning, even though these are * not well defined. We are hoping here that the JVM * does something sensible. * @param waitingFor if non-null, the current task being joined **/ protected void scan(final FJTask waitingFor) { FJTask task = null; // to delay lowering priority until first failure to steal boolean lowered = false; /* Circularly traverse from a random start index. This differs slightly from cilk version that uses a random index for each attempted steal. Exhaustive scanning might impede analytic tractablity of the scheduling policy, but makes it much easier to deal with startup and shutdown. */ FJTaskRunner[] ts = group.getArray(); int idx = victimRNG.nextInt(ts.length); for (int i = 0; i < ts.length; ++i) { FJTaskRunner t = ts[idx]; if (++idx >= ts.length) idx = 0; // circularly traverse if (t != null && t != this) { if (waitingFor != null && waitingFor.isDone()) { break; } else { if (COLLECT_STATS) ++scans; task = t.take(); if (task != null) { if (COLLECT_STATS) ++steals; break; } else if (isInterrupted()) { break; } else if (!lowered) { // if this is first fail, lower priority lowered = true; setPriority(scanPriority); } else { // otherwise we are at low priority; just yield yield(); } } } } if (task == null) { if (COLLECT_STATS) ++scans; task = group.pollEntryQueue(); if (COLLECT_STATS) if (task != null) ++steals; } if (lowered) setPriority(runPriority); if (task != null && !task.isDone()) { if (COLLECT_STATS) ++runs; task.run(); task.setDone(); } } /** * Same as scan, but called when current thread is idling. * It repeatedly scans other threads for tasks, * sleeping while none are available. *
* This differs from scan mainly in that
* since there is no reason to return to recheck any
* condition, we iterate until a task is found, backing
* off via sleeps if necessary.
**/
protected void scanWhileIdling() {
FJTask task = null;
boolean lowered = false;
long iters = 0;
FJTaskRunner[] ts = group.getArray();
int idx = victimRNG.nextInt(ts.length);
do {
for (int i = 0; i < ts.length; ++i) {
FJTaskRunner t = ts[idx];
if (++idx >= ts.length) idx = 0; // circularly traverse
if (t != null && t != this) {
if (COLLECT_STATS) ++scans;
task = t.take();
if (task != null) {
if (COLLECT_STATS) ++steals;
if (lowered) setPriority(runPriority);
group.setActive(this);
break;
}
}
}
if (task == null) {
if (isInterrupted())
return;
if (COLLECT_STATS) ++scans;
task = group.pollEntryQueue();
if (task != null) {
if (COLLECT_STATS) ++steals;
if (lowered) setPriority(runPriority);
group.setActive(this);
} else {
++iters;
// Check here for yield vs sleep to avoid entering group synch lock
if (iters >= group.SCANS_PER_SLEEP) {
group.checkActive(this, iters);
if (isInterrupted())
return;
} else if (!lowered) {
lowered = true;
setPriority(scanPriority);
} else {
yield();
}
}
}
} while (task == null);
if (!task.isDone()) {
if (COLLECT_STATS) ++runs;
task.run();
task.setDone();
}
}
/* ------------ composite operations ------------------- */
/**
* Main runloop
**/
public void run() {
try {
while (!interrupted()) {
FJTask task = pop();
if (task != null) {
if (!task.isDone()) {
// inline FJTask.invoke
if (COLLECT_STATS) ++runs;
task.run();
task.setDone();
}
} else
scanWhileIdling();
}
} finally {
group.setInactive(this);
}
}
/**
* Execute a task in this thread. Generally called when current task
* cannot otherwise continue.
**/
protected final void taskYield() {
FJTask task = pop();
if (task != null) {
if (!task.isDone()) {
if (COLLECT_STATS) ++runs;
task.run();
task.setDone();
}
} else
scan(null);
}
/**
* Process tasks until w is done.
* Equivalent to while(!w.isDone()) taskYield();
**/
protected final void taskJoin(final FJTask w) {
while (!w.isDone()) {
FJTask task = pop();
if (task != null) {
if (!task.isDone()) {
if (COLLECT_STATS) ++runs;
task.run();
task.setDone();
if (task == w) return; // fast exit if we just ran w
}
} else
scan(w);
}
}
/**
* A specialized expansion of
* w.fork(); invoke(v); w.join();
**/
protected final void coInvoke(final FJTask w, final FJTask v) {
// inline push
int t = top;
if (t < (base & (deq.length - 1)) + deq.length) {
deq[t & (deq.length - 1)].put(w);
top = t + 1;
// inline invoke
if (!v.isDone()) {
if (COLLECT_STATS) ++runs;
v.run();
v.setDone();
}
// inline taskJoin
while (!w.isDone()) {
FJTask task = pop();
if (task != null) {
if (!task.isDone()) {
if (COLLECT_STATS) ++runs;
task.run();
task.setDone();
if (task == w) return; // fast exit if we just ran w
}
} else
scan(w);
}
} else // handle non-inlinable cases
slowCoInvoke(w, v);
}
/**
* Backup to handle noninlinable cases of coInvoke
**/
protected void slowCoInvoke(final FJTask w, final FJTask v) {
push(w); // let push deal with overflow
FJTask.invoke(v);
taskJoin(w);
}
/**
* Array-based version of coInvoke
**/
protected final void coInvoke(FJTask[] tasks) {
int nforks = tasks.length - 1;
// inline bulk push of all but one task
int t = top;
if (nforks >= 0 && t + nforks < (base & (deq.length - 1)) + deq.length) {
for (int i = 0; i < nforks; ++i) {
deq[t++ & (deq.length - 1)].put(tasks[i]);
top = t;
}
// inline invoke of one task
FJTask v = tasks[nforks];
if (!v.isDone()) {
if (COLLECT_STATS) ++runs;
v.run();
v.setDone();
}
// inline taskJoins
for (int i = 0; i < nforks; ++i) {
FJTask w = tasks[i];
while (!w.isDone()) {
FJTask task = pop();
if (task != null) {
if (!task.isDone()) {
if (COLLECT_STATS) ++runs;
task.run();
task.setDone();
}
} else
scan(w);
}
}
} else // handle non-inlinable cases
slowCoInvoke(tasks);
}
/**
* Backup to handle atypical or noninlinable cases of coInvoke
**/
protected void slowCoInvoke(FJTask[] tasks) {
for (int i = 0; i < tasks.length; ++i) push(tasks[i]);
for (int i = 0; i < tasks.length; ++i) taskJoin(tasks[i]);
}
}
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/FJTaskRunnerGroup.java 0000644 0001750 0001750 00000052140 10730503124 031357 0 ustar twerner twerner /*
File: FJTaskRunnerGroup.java
Originally written by Doug Lea and released into the public domain.
This may be used for any purposes whatsoever without acknowledgment.
Thanks for the assistance and support of Sun Microsystems Labs,
and everyone contributing, testing, and using this code.
History:
Date Who What
7Jan1999 dl First public release
12Jan1999 dl made getActiveCount public; misc minor cleanup.
14Jan1999 dl Added executeTask
20Jan1999 dl Allow use of priorities; reformat stats
6Feb1999 dl Lazy thread starts
27Apr1999 dl Renamed
*/
package org.logicalcobwebs.concurrent;
/**
* A stripped down analog of a ThreadGroup used for
* establishing and managing FJTaskRunner threads.
* ThreadRunnerGroups serve as the control boundary separating
* the general world of normal threads from the specialized world
* of FJTasks.
*
* By intent, this class does not subclass java.lang.ThreadGroup, and * does not support most methods found in ThreadGroups, since they * would make no sense for FJTaskRunner threads. In fact, the class * does not deal with ThreadGroups at all. If you want to restrict * a FJTaskRunnerGroup to a particular ThreadGroup, you can create * it from within that ThreadGroup. *
* The main contextual parameter for a FJTaskRunnerGroup is * the group size, established in the constructor. * Groups must be of a fixed size. * There is no way to dynamically increase or decrease the number * of threads in an existing group. *
* In general, the group size should be equal to the number
* of CPUs on the system. (Unfortunately, there is no portable
* means of automatically detecting the number of CPUs on a JVM, so there is
* no good way to automate defaults.) In principle, when
* FJTasks are used for computation-intensive tasks, having only
* as many threads as CPUs should minimize bookkeeping overhead
* and contention, and so maximize throughput. However, because
* FJTaskRunners lie atop Java threads, and in turn operating system
* thread support and scheduling policies,
* it is very possible that using more threads
* than CPUs will improve overall throughput even though it adds
* to overhead. This will always be so if FJTasks are I/O bound.
* So it may pay to experiment a bit when tuning on particular platforms.
* You can also use setRunPriorities to either
* increase or decrease the priorities of active threads, which
* may interact with group size choice.
*
* In any case, overestimating group sizes never * seriously degrades performance (at least within reasonable bounds). * You can also use a value * less than the number of CPUs in order to reserve processing * for unrelated threads. *
* There are two general styles for using a FJTaskRunnerGroup. * You can create one group per entire program execution, for example * as a static singleton, and use it for all parallel tasks: *
* class Tasks {
* static FJTaskRunnerGroup group;
* public void initialize(int groupsize) {
* group = new FJTaskRunnerGroup(groupSize);
* }
* // ...
* }
*
* Alternatively, you can make new groups on the fly and use them only for
* particular task sets. This is more flexible,,
* and leads to more controllable and deterministic execution patterns,
* but it encounters greater overhead on startup. Also, to reclaim
* system resources, you should
* call FJTaskRunnerGroup.interruptAll when you are done
* using one-shot groups. Otherwise, because FJTaskRunners set
* Thread.isDaemon
* status, they will not normally be reclaimed until program termination.
*
* The main supported methods are execute,
* which starts a task processed by FJTaskRunner threads,
* and invoke, which starts one and waits for completion.
* For example, you might extend the above FJTasks
* class to support a task-based computation, say, the
* Fib class from the FJTask documentation:
*
* class Tasks { // continued
* // ...
* static int fib(int n) {
* try {
* Fib f = new Fib(n);
* group.invoke(f);
* return f.getAnswer();
* }
* catch (InterruptedException ex) {
* throw new Error("Interrupted during computation");
* }
* }
* }
*
*
* Method stats() can be used to monitor performance.
* Both FJTaskRunnerGroup and FJTaskRunner may be compiled with
* the compile-time constant COLLECT_STATS set to false. In this
* case, various simple counts reported in stats() are not collected.
* On platforms tested,
* this leads to such a tiny performance improvement that there is
* very little motivation to bother.
*
*
[ Introduction to this package. ] *
* @see FJTask * @see FJTaskRunner **/ public class FJTaskRunnerGroup implements Executor { /** The threads in this group **/ protected final FJTaskRunner[] threads; /** Group-wide queue for tasks entered via execute() **/ protected final LinkedQueue entryQueue = new LinkedQueue(); /** Number of threads that are not waiting for work **/ protected int activeCount = 0; /** Number of threads that have been started. Used to avoid unecessary contention during startup of task sets. **/ protected int nstarted = 0; /** * Compile-time constant. If true, various counts of * runs, waits, etc., are maintained. These are NOT * updated with synchronization, so statistics reports * might not be accurate. **/ static final boolean COLLECT_STATS = true; // static final boolean COLLECT_STATS = false; // for stats /** The time at which this ThreadRunnerGroup was constructed **/ long initTime = 0; /** Total number of executes or invokes **/ int entries = 0; static final int DEFAULT_SCAN_PRIORITY = Thread.MIN_PRIORITY + 1; /** * Create a FJTaskRunnerGroup with the indicated number * of FJTaskRunner threads. Normally, the best size to use is * the number of CPUs on the system. *
* The threads in a FJTaskRunnerGroup are created with their
* isDaemon status set, so do not normally need to be
* shut down manually upon program termination.
**/
public FJTaskRunnerGroup(int groupSize) {
threads = new FJTaskRunner[groupSize];
initializeThreads();
initTime = System.currentTimeMillis();
}
/**
* Arrange for execution of the given task
* by placing it in a work queue. If the argument
* is not of type FJTask, it is embedded in a FJTask via
* FJTask.Wrap.
* @exception InterruptedException if current Thread is
* currently interrupted
**/
public void execute(Runnable r) throws InterruptedException {
if (r instanceof FJTask) {
entryQueue.put((FJTask) r);
} else {
entryQueue.put(new FJTask.Wrap(r));
}
signalNewTask();
}
/**
* Specialized form of execute called only from within FJTasks
**/
public void executeTask(FJTask t) {
try {
entryQueue.put(t);
signalNewTask();
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
/**
* Start a task and wait it out. Returns when the task completes.
* @exception InterruptedException if current Thread is
* interrupted before completion of the task.
**/
public void invoke(Runnable r) throws InterruptedException {
InvokableFJTask w = new InvokableFJTask(r);
entryQueue.put(w);
signalNewTask();
w.awaitTermination();
}
/**
* Try to shut down all FJTaskRunner threads in this group
* by interrupting them all. This method is designed
* to be used during cleanup when it is somehow known
* that all threads are idle.
* FJTaskRunners only
* check for interruption when they are not otherwise
* processing a task (and its generated subtasks,
* if any), so if any threads are active, shutdown may
* take a while, and may lead to unpredictable
* task processing.
**/
public void interruptAll() {
// paranoically interrupt current thread last if in group.
Thread current = Thread.currentThread();
boolean stopCurrent = false;
for (int i = 0; i < threads.length; ++i) {
Thread t = threads[i];
if (t == current)
stopCurrent = true;
else
t.interrupt();
}
if (stopCurrent)
current.interrupt();
}
/**
* Set the priority to use while a FJTaskRunner is
* polling for new tasks to perform. Default
* is currently Thread.MIN_PRIORITY+1. The value
* set may not go into effect immediately, but
* will be used at least the next time a thread scans for work.
**/
public synchronized void setScanPriorities(int pri) {
for (int i = 0; i < threads.length; ++i) {
FJTaskRunner t = threads[i];
t.setScanPriority(pri);
if (!t.active) t.setPriority(pri);
}
}
/**
* Set the priority to use while a FJTaskRunner is
* actively running tasks. Default
* is the priority that was in effect by the thread that
* constructed this FJTaskRunnerGroup. Setting this value
* while threads are running may momentarily result in
* them running at this priority even when idly waiting for work.
**/
public synchronized void setRunPriorities(int pri) {
for (int i = 0; i < threads.length; ++i) {
FJTaskRunner t = threads[i];
t.setRunPriority(pri);
if (t.active) t.setPriority(pri);
}
}
/** Return the number of FJTaskRunner threads in this group **/
public int size() {
return threads.length;
}
/**
* Return the number of threads that are not idly waiting for work.
* Beware that even active threads might not be doing any useful
* work, but just spinning waiting for other dependent tasks.
* Also, since this is just a snapshot value, some tasks
* may be in the process of becoming idle.
**/
public synchronized int getActiveCount() {
return activeCount;
}
/**
* Prints various snapshot statistics to System.out.
*
* Cautions: Some statistics are updated and gathered * without synchronization, * so may not be accurate. However, reported counts may be considered * as lower bounds of actual values. * Some values may be zero if classes are compiled * with COLLECT_STATS set to false. (FJTaskRunner and FJTaskRunnerGroup * classes can be independently compiled with different values of * COLLECT_STATS.) Also, the counts are maintained as ints so could * overflow in exceptionally long-lived applications. *
* These statistics can be useful when tuning algorithms or diagnosing * problems. For example: *
* This is not treated as a user-tunable parameter because * good values do not appear to vary much across JVMs or * applications. Its main role is to help avoid some * useless spinning and contention during task startup. **/ static final long SCANS_PER_SLEEP = 15; /** * The maximum time (in msecs) to sleep when a thread is idle, * yet others are not, so may eventually generate work that * the current thread can steal. This value reflects the maximum time * that a thread may sleep when it possibly should not, because there * are other active threads that might generate work. In practice, * designs in which some threads become stalled because others * are running yet not generating tasks are not likely to work * well in this framework anyway, so the exact value does not matter * too much. However, keeping it in the sub-second range does * help smooth out startup and shutdown effects. **/ static final long MAX_SLEEP_TIME = 100; /** * Set active status of thread t to false, and * then wait until: (a) there is a task in the entry * queue, or (b) other threads are active, or (c) the current * thread is interrupted. Upon return, it * is not certain that there will be work available. * The thread must itself check. *
* The main underlying reason * for these mechanics is that threads do not * signal each other when they add elements to their queues. * (This would add to task overhead, reduce locality. * and increase contention.) * So we must rely on a tamed form of polling. However, tasks * inserted into the entry queue do result in signals, so * tasks can wait on these if all of them are otherwise idle. **/ protected synchronized void checkActive(FJTaskRunner t, long scans) { setInactive(t); try { // if nothing available, do a hard wait if (activeCount == 0 && entryQueue.peek() == null) { wait(); } else { // If there is possibly some work, // sleep for a while before rechecking long msecs = scans / SCANS_PER_SLEEP; if (msecs > MAX_SLEEP_TIME) msecs = MAX_SLEEP_TIME; int nsecs = (msecs == 0) ? 1 : 0; // forces shortest possible sleep wait(msecs, nsecs); } } catch (InterruptedException ex) { notify(); // avoid lost notifies on interrupts Thread.currentThread().interrupt(); } } /* ------------ Utility methods ------------- */ /** * Start or wake up any threads waiting for work **/ protected synchronized void signalNewTask() { if (COLLECT_STATS) ++entries; if (nstarted < threads.length) threads[nstarted++].start(); else notify(); } /** * Create all FJTaskRunner threads in this group. **/ protected void initializeThreads() { for (int i = 0; i < threads.length; ++i) threads[i] = new FJTaskRunner(this); } /** * Wrap wait/notify mechanics around a task so that * invoke() can wait it out **/ protected static final class InvokableFJTask extends FJTask { protected final Runnable wrapped; protected boolean terminated = false; protected InvokableFJTask(Runnable r) { wrapped = r; } public void run() { try { if (wrapped instanceof FJTask) FJTask.invoke((FJTask) (wrapped)); else wrapped.run(); } finally { setTerminated(); } } protected synchronized void setTerminated() { terminated = true; notifyAll(); } protected synchronized void awaitTermination() throws InterruptedException { while (!terminated) wait(); } } } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/FutureResult.java 0000644 0001750 0001750 00000014367 10730503124 030510 0 ustar twerner twerner /* File: FutureResult.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 30Jun1998 dl Create public version */ package org.logicalcobwebs.concurrent; import java.lang.reflect.InvocationTargetException; /** * A class maintaining a single reference variable serving as the result * of an operation. The result cannot be accessed until it has been set. *
* Sample Usage
*
* class ImageRenderer { Image render(byte[] raw); }
* class App {
* Executor executor = ...
* ImageRenderer renderer = ...
* void display(byte[] rawimage) {
* try {
* FutureResult futureImage = new FutureResult();
* Runnable command = futureImage.setter(new Callable() {
* public Object call() { return renderer.render(rawImage); }
* });
* executor.execute(command);
* drawBorders(); // do other things while executing
* drawCaption();
* drawImage((Image)(futureImage.get())); // use future
* }
* catch (InterruptedException ex) { return; }
* catch (InvocationTargetException ex) { cleanup(); return; }
* }
* }
*
* [ Introduction to this package. ] * @see Executor **/ public class FutureResult { /** The result of the operation **/ protected Object value_ = null; /** Status -- true after first set **/ protected boolean ready_ = false; /** the exception encountered by operation producing result **/ protected InvocationTargetException exception_ = null; /** * Create an initially unset FutureResult **/ public FutureResult() { } /** * Return a Runnable object that, when run, will set the result value. * @param function - a Callable object whose result will be * held by this FutureResult. * @return A Runnable object that, when run, will call the * function and (eventually) set the result. **/ public Runnable setter(final Callable function) { return new Runnable() { public void run() { try { set(function.call()); } catch (Throwable ex) { setException(ex); } } }; } /** internal utility: either get the value or throw the exception **/ protected Object doGet() throws InvocationTargetException { if (exception_ != null) throw exception_; else return value_; } /** * Access the reference, waiting if necessary until it is ready. * @return current value * @exception InterruptedException if current thread has been interrupted * @exception InvocationTargetException if the operation * producing the value encountered an exception. **/ public synchronized Object get() throws InterruptedException, InvocationTargetException { while (!ready_) wait(); return doGet(); } /** * Wait at most msecs to access the reference. * @return current value * @exception TimeoutException if not ready after msecs * @exception InterruptedException if current thread has been interrupted * @exception InvocationTargetException if the operation * producing the value encountered an exception. **/ public synchronized Object timedGet(long msecs) throws TimeoutException, InterruptedException, InvocationTargetException { long startTime = (msecs <= 0) ? 0 : System.currentTimeMillis(); long waitTime = msecs; if (ready_) return doGet(); else if (waitTime <= 0) throw new TimeoutException(msecs); else { for (; ;) { wait(waitTime); if (ready_) return doGet(); else { waitTime = msecs - (System.currentTimeMillis() - startTime); if (waitTime <= 0) throw new TimeoutException(msecs); } } } } /** * Set the reference, and signal that it is ready. It is not * considered an error to set the value more than once, * but it is not something you would normally want to do. * @param newValue The value that will be returned by a subsequent get(); **/ public synchronized void set(Object newValue) { value_ = newValue; ready_ = true; notifyAll(); } /** * Set the exception field, also setting ready status. * @param ex The exception. It will be reported out wrapped * within an InvocationTargetException **/ public synchronized void setException(Throwable ex) { exception_ = new InvocationTargetException(ex); ready_ = true; notifyAll(); } /** * Get the exception, or null if there isn't one (yet). * This does not wait until the future is ready, so should * ordinarily only be called if you know it is. * @return the exception encountered by the operation * setting the future, wrapped in an InvocationTargetException **/ public synchronized InvocationTargetException getException() { return exception_; } /** * Return whether the reference or exception have been set. * @return true if has been set. else false **/ public synchronized boolean isReady() { return ready_; } /** * Access the reference, even if not ready * @return current value **/ public synchronized Object peek() { return value_; } /** * Clear the value and exception and set to not-ready, * allowing this FutureResult to be reused. This is not * particularly recommended and must be done only * when you know that no other object is depending on the * properties of this FutureResult. **/ public synchronized void clear() { value_ = null; exception_ = null; ready_ = false; } } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/LinkedNode.java 0000644 0001750 0001750 00000001612 10730503124 030040 0 ustar twerner twerner /* File: LinkedNode.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 11Jun1998 dl Create public version 25may2000 dl Change class access to public 26nov2001 dl Added no-arg constructor, all public access. */ package org.logicalcobwebs.concurrent; /** A standard linked list node used in various queue classes **/ public class LinkedNode { public Object value; public LinkedNode next; public LinkedNode() { } public LinkedNode(Object x) { value = x; } public LinkedNode(Object x, LinkedNode n) { value = x; next = n; } } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/LinkedQueue.java 0000644 0001750 0001750 00000013007 10730503124 030240 0 ustar twerner twerner /* File: LinkedQueue.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 11Jun1998 dl Create public version 25aug1998 dl added peek 10dec1998 dl added isEmpty 10oct1999 dl lock on node object to ensure visibility */ package org.logicalcobwebs.concurrent; /** * A linked list based channel implementation. * The algorithm avoids contention between puts * and takes when the queue is not empty. * Normally a put and a take can proceed simultaneously. * (Although it does not allow multiple concurrent puts or takes.) * This class tends to perform more efficently than * other Channel implementations in producer/consumer * applications. *
[ Introduction to this package. ] **/ public class LinkedQueue implements Channel { /** * Dummy header node of list. The first actual node, if it exists, is always * at head_.next. After each take, the old first node becomes the head. **/ protected LinkedNode head_; /** * Helper monitor for managing access to last node. **/ protected final Object putLock_ = new Object(); /** * The last node of list. Put() appends to list, so modifies last_ **/ protected LinkedNode last_; /** * The number of threads waiting for a take. * Notifications are provided in put only if greater than zero. * The bookkeeping is worth it here since in reasonably balanced * usages, the notifications will hardly ever be necessary, so * the call overhead to notify can be eliminated. **/ protected int waitingForTake_ = 0; public LinkedQueue() { head_ = new LinkedNode(null); last_ = head_; } /** Main mechanics for put/offer **/ protected void insert(Object x) { synchronized (putLock_) { LinkedNode p = new LinkedNode(x); synchronized (last_) { last_.next = p; last_ = p; } if (waitingForTake_ > 0) putLock_.notify(); } } /** Main mechanics for take/poll **/ protected synchronized Object extract() { synchronized (head_) { Object x = null; LinkedNode first = head_.next; if (first != null) { x = first.value; first.value = null; head_ = first; } return x; } } public void put(Object x) throws InterruptedException { if (x == null) throw new IllegalArgumentException(); if (Thread.interrupted()) throw new InterruptedException(); insert(x); } public boolean offer(Object x, long msecs) throws InterruptedException { if (x == null) throw new IllegalArgumentException(); if (Thread.interrupted()) throw new InterruptedException(); insert(x); return true; } public Object take() throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); // try to extract. If fail, then enter wait-based retry loop Object x = extract(); if (x != null) return x; else { synchronized (putLock_) { try { ++waitingForTake_; for (; ;) { x = extract(); if (x != null) { --waitingForTake_; return x; } else { putLock_.wait(); } } } catch (InterruptedException ex) { --waitingForTake_; putLock_.notify(); throw ex; } } } } public Object peek() { synchronized (head_) { LinkedNode first = head_.next; if (first != null) return first.value; else return null; } } public boolean isEmpty() { synchronized (head_) { return head_.next == null; } } public Object poll(long msecs) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); Object x = extract(); if (x != null) return x; else { synchronized (putLock_) { try { long waitTime = msecs; long start = (msecs <= 0) ? 0 : System.currentTimeMillis(); ++waitingForTake_; for (; ;) { x = extract(); if (x != null || waitTime <= 0) { --waitingForTake_; return x; } else { putLock_.wait(waitTime); waitTime = msecs - (System.currentTimeMillis() - start); } } } catch (InterruptedException ex) { --waitingForTake_; putLock_.notify(); throw ex; } } } } } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/Puttable.java 0000644 0001750 0001750 00000005076 10730503124 027614 0 ustar twerner twerner /* File: Puttable.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 11Jun1998 dl Create public version */ package org.logicalcobwebs.concurrent; /** * This interface exists to enable stricter type checking * for channels. A method argument or instance variable * in a producer object can be declared as only a Puttable * rather than a Channel, in which case a Java compiler * will disallow take operations. *
* Full method descriptions appear in the Channel interface. *
[ Introduction to this package. ] * @see Channel * @see Takable **/ public interface Puttable { /** * Place item in the channel, possibly waiting indefinitely until * it can be accepted. Channels implementing the BoundedChannel * subinterface are generally guaranteed to block on puts upon * reaching capacity, but other implementations may or may not block. * @param item the element to be inserted. Should be non-null. * @exception InterruptedException if the current thread has * been interrupted at a point at which interruption * is detected, in which case the element is guaranteed not * to be inserted. Otherwise, on normal return, the element is guaranteed * to have been inserted. **/ public void put(Object item) throws InterruptedException; /** * Place item in channel only if it can be accepted within * msecs milliseconds. The time bound is interpreted in * a coarse-grained, best-effort fashion. * @param item the element to be inserted. Should be non-null. * @param msecs the number of milliseconds to wait. If less than * or equal to zero, the method does not perform any timed waits, * but might still require * access to a synchronization lock, which can impose unbounded * delay if there is a lot of contention for the channel. * @return true if accepted, else false * @exception InterruptedException if the current thread has * been interrupted at a point at which interruption * is detected, in which case the element is guaranteed not * to be inserted (i.e., is equivalent to a false return). **/ public boolean offer(Object item, long msecs) throws InterruptedException; } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/ReadWriteLock.java 0000644 0001750 0001750 00000004544 10730503124 030532 0 ustar twerner twerner /* File: ReadWriteLock.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 11Jun1998 dl Create public version */ package org.logicalcobwebs.concurrent; /** * ReadWriteLocks maintain a pair of associated locks. * The readLock may be held simultanously by multiple * reader threads, so long as there are no writers. The writeLock * is exclusive. ReadWrite locks are generally preferable to * plain Sync locks or synchronized methods in cases where: *
* Standard usage: *
* class X {
* ReadWriteLock rw;
* // ...
*
* public void read() throws InterruptedException {
* rw.readLock().acquire();
* try {
* // ... do the read
* }
* finally {
* rw.readlock().release()
* }
* }
*
*
* public void write() throws InterruptedException {
* rw.writeLock().acquire();
* try {
* // ... do the write
* }
* finally {
* rw.writelock().release()
* }
* }
* }
*
* @see Sync
* [ Introduction to this package. ] **/ public interface ReadWriteLock { /** get the readLock **/ Sync readLock(); /** get the writeLock **/ Sync writeLock(); } ././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/ReaderPreferenceReadWriteLock.java libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/ReaderPreferenceReadWriteLock.java0000644 0001750 0001750 00000002001 10730503124 033636 0 ustar twerner twerner /* File: ReaderPreferenceReadWriteLock.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 11Jun1998 dl Create public version */ package org.logicalcobwebs.concurrent; /** * A ReadWriteLock that prefers waiting readers over * waiting writers when there is contention. The range of applicability * of this class is very limited. In the majority of situations, * writer preference locks provide more reasonable semantics. * *
[ Introduction to this package. ] **/ public class ReaderPreferenceReadWriteLock extends WriterPreferenceReadWriteLock { protected boolean allowReader() { return activeWriter_ == null; } } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/Sync.java 0000644 0001750 0001750 00000025574 10730503124 026755 0 ustar twerner twerner /* File: Sync.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 11Jun1998 dl Create public version 5Aug1998 dl Added some convenient time constants */ package org.logicalcobwebs.concurrent; /** * Main interface for locks, gates, and conditions. *
* Sync objects isolate waiting and notification for particular * logical states, resource availability, events, and the like that are * shared across multiple threads. Use of Syncs sometimes * (but by no means always) adds flexibility and efficiency * compared to the use of plain java monitor methods * and locking, and are sometimes (but by no means always) * simpler to program with. *
* * Most Syncs are intended to be used primarily (although * not exclusively) in before/after constructions such as: *
* class X {
* Sync gate;
* // ...
*
* public void m() {
* try {
* gate.acquire(); // block until condition holds
* try {
* // ... method body
* }
* finally {
* gate.release()
* }
* }
* catch (InterruptedException ex) {
* // ... evasive action
* }
* }
*
* public void m2(Sync cond) { // use supplied condition
* try {
* if (cond.attempt(10)) { // try the condition for 10 ms
* try {
* // ... method body
* }
* finally {
* cond.release()
* }
* }
* }
* catch (InterruptedException ex) {
* // ... evasive action
* }
* }
* }
*
* Syncs may be used in somewhat tedious but more flexible replacements
* for built-in Java synchronized blocks. For example:
*
* class HandSynched {
* private double state_ = 0.0;
* private final Sync lock; // use lock type supplied in constructor
* public HandSynched(Sync l) { lock = l; }
*
* public void changeState(double d) {
* try {
* lock.acquire();
* try { state_ = updateFunction(d); }
* finally { lock.release(); }
* }
* catch(InterruptedException ex) { }
* }
*
* public double getState() {
* double d = 0.0;
* try {
* lock.acquire();
* try { d = accessFunction(state_); }
* finally { lock.release(); }
* }
* catch(InterruptedException ex){}
* return d;
* }
* private double updateFunction(double d) { ... }
* private double accessFunction(double d) { ... }
* }
*
* If you have a lot of such methods, and they take a common
* form, you can standardize this using wrappers. Some of these
* wrappers are standardized in LockedExecutor, but you can make others.
* For example:
*
* class HandSynchedV2 {
* private double state_ = 0.0;
* private final Sync lock; // use lock type supplied in constructor
* public HandSynchedV2(Sync l) { lock = l; }
*
* protected void runSafely(Runnable r) {
* try {
* lock.acquire();
* try { r.run(); }
* finally { lock.release(); }
* }
* catch (InterruptedException ex) { // propagate without throwing
* Thread.currentThread().interrupt();
* }
* }
*
* public void changeState(double d) {
* runSafely(new Runnable() {
* public void run() { state_ = updateFunction(d); }
* });
* }
* // ...
* }
*
* * One reason to bother with such constructions is to use deadlock- * avoiding back-offs when dealing with locks involving multiple objects. * For example, here is a Cell class that uses attempt to back-off * and retry if two Cells are trying to swap values with each other * at the same time. *
* class Cell {
* long value;
* Sync lock = ... // some sync implementation class
* void swapValue(Cell other) {
* for (;;) {
* try {
* lock.acquire();
* try {
* if (other.lock.attempt(100)) {
* try {
* long t = value;
* value = other.value;
* other.value = t;
* return;
* }
* finally { other.lock.release(); }
* }
* }
* finally { lock.release(); }
* }
* catch (InterruptedException ex) { return; }
* }
* }
* }
*
* * Here is an even fancier version, that uses lock re-ordering * upon conflict: *
* class Cell {
* long value;
* Sync lock = ...;
* private static boolean trySwap(Cell a, Cell b) {
* a.lock.acquire();
* try {
* if (!b.lock.attempt(0))
* return false;
* try {
* long t = a.value;
* a.value = b.value;
* b.value = t;
* return true;
* }
* finally { other.lock.release(); }
* }
* finally { lock.release(); }
* return false;
* }
*
* void swapValue(Cell other) {
* try {
* while (!trySwap(this, other) &&
* !tryswap(other, this))
* Thread.sleep(1);
* }
* catch (InterruptedException ex) { return; }
* }
*}
*
* * Interruptions are in general handled as early as possible. * Normally, InterruptionExceptions are thrown * in acquire and attempt(msec) if interruption * is detected upon entry to the method, as well as in any * later context surrounding waits. * However, interruption status is ignored in release(); *
* Timed versions of attempt report failure via return value. * If so desired, you can transform such constructions to use exception * throws via *
* if (!c.attempt(timeval)) throw new TimeoutException(timeval); **
* The TimoutSync wrapper class can be used to automate such usages. *
* All time values are expressed in milliseconds as longs, which have a maximum * value of Long.MAX_VALUE, or almost 300,000 centuries. It is not * known whether JVMs actually deal correctly with such extreme values. * For convenience, some useful time values are defined as static constants. *
* All implementations of the three Sync methods guarantee to
* somehow employ Java synchronized methods or blocks,
* and so entail the memory operations described in JLS
* chapter 17 which ensure that variables are loaded and flushed
* within before/after constructions.
*
* Syncs may also be used in spinlock constructions. Although * it is normally best to just use acquire(), various forms * of busy waits can be implemented. For a simple example * (but one that would probably never be preferable to using acquire()): *
* class X {
* Sync lock = ...
* void spinUntilAcquired() throws InterruptedException {
* // Two phase.
* // First spin without pausing.
* int purespins = 10;
* for (int i = 0; i < purespins; ++i) {
* if (lock.attempt(0))
* return true;
* }
* // Second phase - use timed waits
* long waitTime = 1; // 1 millisecond
* for (;;) {
* if (lock.attempt(waitTime))
* return true;
* else
* waitTime = waitTime * 3 / 2 + 1; // increase 50%
* }
* }
* }
*
* * In addition pure synchronization control, Syncs * may be useful in any context requiring before/after methods. * For example, you can use an ObservableSync * (perhaps as part of a LayeredSync) in order to obtain callbacks * before and after each method invocation for a given class. *
*
[ Introduction to this package. ] **/ public interface Sync { /** * Wait (possibly forever) until successful passage. * Fail only upon interuption. Interruptions always result in * `clean' failures. On failure, you can be sure that it has not * been acquired, and that no * corresponding release should be performed. Conversely, * a normal return guarantees that the acquire was successful. **/ public void acquire() throws InterruptedException; /** * Wait at most msecs to pass; report whether passed. *
* The method has best-effort semantics: * The msecs bound cannot * be guaranteed to be a precise upper bound on wait time in Java. * Implementations generally can only attempt to return as soon as possible * after the specified bound. Also, timers in Java do not stop during garbage * collection, so timeouts can occur just because a GC intervened. * So, msecs arguments should be used in * a coarse-grained manner. Further, * implementations cannot always guarantee that this method * will return at all without blocking indefinitely when used in * unintended ways. For example, deadlocks may be encountered * when called in an unintended context. *
* @param msecs the number of milleseconds to wait. * An argument less than or equal to zero means not to wait at all. * However, this may still require * access to a synchronization lock, which can impose unbounded * delay if there is a lot of contention among threads. * @return true if acquired **/ public boolean attempt(long msecs) throws InterruptedException; /** * Potentially enable others to pass. *
* Because release does not raise exceptions, * it can be used in `finally' clauses without requiring extra * embedded try/catch blocks. But keep in mind that * as with any java method, implementations may * still throw unchecked exceptions such as Error or NullPointerException * when faced with uncontinuable errors. However, these should normally * only be caught by higher-level error handlers. **/ public void release(); /** One second, in milliseconds; convenient as a time-out value **/ public static final long ONE_SECOND = 1000; /** One minute, in milliseconds; convenient as a time-out value **/ public static final long ONE_MINUTE = 60 * ONE_SECOND; /** One hour, in milliseconds; convenient as a time-out value **/ public static final long ONE_HOUR = 60 * ONE_MINUTE; /** One day, in milliseconds; convenient as a time-out value **/ public static final long ONE_DAY = 24 * ONE_HOUR; /** One week, in milliseconds; convenient as a time-out value **/ public static final long ONE_WEEK = 7 * ONE_DAY; /** One year in milliseconds; convenient as a time-out value **/ // Not that it matters, but there is some variation across // standard sources about value at msec precision. // The value used is the same as in java.util.GregorianCalendar public static final long ONE_YEAR = (long) (365.2425 * ONE_DAY); /** One century in milliseconds; convenient as a time-out value **/ public static final long ONE_CENTURY = 100 * ONE_YEAR; } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/SynchronizedInt.java 0000644 0001750 0001750 00000013476 10730503124 031171 0 ustar twerner twerner /* File: SynchronizedInt.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 19Jun1998 dl Create public version */ package org.logicalcobwebs.concurrent; /** * A class useful for offloading synch for int instance variables. * *
[ Introduction to this package. ] **/ public class SynchronizedInt extends SynchronizedVariable implements Comparable, Cloneable { protected int value_; /** * Make a new SynchronizedInt with the given initial value, * and using its own internal lock. **/ public SynchronizedInt(int initialValue) { super(); value_ = initialValue; } /** * Make a new SynchronizedInt with the given initial value, * and using the supplied lock. **/ public SynchronizedInt(int initialValue, Object lock) { super(lock); value_ = initialValue; } /** * Return the current value **/ public final int get() { synchronized (lock_) { return value_; } } /** * Set to newValue. * @return the old value **/ public int set(int newValue) { synchronized (lock_) { int old = value_; value_ = newValue; return old; } } /** * Set value to newValue only if it is currently assumedValue. * @return true if successful **/ public boolean commit(int assumedValue, int newValue) { synchronized (lock_) { boolean success = (assumedValue == value_); if (success) value_ = newValue; return success; } } /** * Atomically swap values with another SynchronizedInt. * Uses identityHashCode to avoid deadlock when * two SynchronizedInts attempt to simultaneously swap with each other. * (Note: Ordering via identyHashCode is not strictly guaranteed * by the language specification to return unique, orderable * values, but in practice JVMs rely on them being unique.) * @return the new value **/ public int swap(SynchronizedInt other) { if (other == this) return get(); SynchronizedInt fst = this; SynchronizedInt snd = other; if (System.identityHashCode(fst) > System.identityHashCode(snd)) { fst = other; snd = this; } synchronized (fst.lock_) { synchronized (snd.lock_) { fst.set(snd.set(fst.get())); return get(); } } } /** * Increment the value. * @return the new value **/ public int increment() { synchronized (lock_) { return ++value_; } } /** * Decrement the value. * @return the new value **/ public int decrement() { synchronized (lock_) { return --value_; } } /** * Add amount to value (i.e., set value += amount) * @return the new value **/ public int add(int amount) { synchronized (lock_) { return value_ += amount; } } /** * Subtract amount from value (i.e., set value -= amount) * @return the new value **/ public int subtract(int amount) { synchronized (lock_) { return value_ -= amount; } } /** * Multiply value by factor (i.e., set value *= factor) * @return the new value **/ public synchronized int multiply(int factor) { synchronized (lock_) { return value_ *= factor; } } /** * Divide value by factor (i.e., set value /= factor) * @return the new value **/ public int divide(int factor) { synchronized (lock_) { return value_ /= factor; } } /** * Set the value to the negative of its old value * @return the new value **/ public int negate() { synchronized (lock_) { value_ = -value_; return value_; } } /** * Set the value to its complement * @return the new value **/ public int complement() { synchronized (lock_) { value_ = ~value_; return value_; } } /** * Set value to value & b. * @return the new value **/ public int and(int b) { synchronized (lock_) { value_ = value_ & b; return value_; } } /** * Set value to value | b. * @return the new value **/ public int or(int b) { synchronized (lock_) { value_ = value_ | b; return value_; } } /** * Set value to value ^ b. * @return the new value **/ public int xor(int b) { synchronized (lock_) { value_ = value_ ^ b; return value_; } } public int compareTo(int other) { int val = get(); return (val < other) ? -1 : (val == other) ? 0 : 1; } public int compareTo(SynchronizedInt other) { return compareTo(other.get()); } public int compareTo(Object other) { return compareTo((SynchronizedInt) other); } public boolean equals(Object other) { if (other != null && other instanceof SynchronizedInt) return get() == ((SynchronizedInt) other).get(); else return false; } public int hashCode() { return get(); } public String toString() { return String.valueOf(get()); } } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/SynchronizedVariable.java 0000644 0001750 0001750 00000017512 10730503124 032157 0 ustar twerner twerner /* File: SynchronizedVariable.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 30Jun1998 dl Create public version */ package org.logicalcobwebs.concurrent; /** * Base class for simple, small classes * maintaining single values that are always accessed * and updated under synchronization. Since defining them for only * some types seemed too arbitrary, they exist for all basic types, * although it is hard to imagine uses for some. *
* These classes mainly exist so that you do not have to go to the * trouble of writing your own miscellaneous classes and methods * in situations including: *
final. This
* helps avoid the need to synchronize just to obtain the reference
* to the synchronized variable itself.
*
* static variables. It almost
* always works out better to rely on synchronization internal
* to these objects, rather than class locks.
* * While they cannot, by nature, share much code, * all of these classes work in the same way. *
* Construction
* Synchronized variables are always constructed holding an
* initial value of the associated type. Constructors also
* establish the lock to use for all methods:
*
* Update methods
* Each class supports several kinds of update methods:
*
set method that sets to a new value and returns
* previous value. For example, for a SynchronizedBoolean b,
* boolean old = b.set(true) performs a test-and-set.
* *
commit method that sets to new value only
* if currently holding a given value.
*
* For example, here is a class that uses an optimistic update
* loop to recompute a count variable represented as a
* SynchronizedInt.
*
* class X {
* private final SynchronizedInt count = new SynchronizedInt(0);
*
* static final int MAX_RETRIES = 1000;
*
* public boolean recomputeCount() throws InterruptedException {
* for (int i = 0; i < MAX_RETRIES; ++i) {
* int current = count.get();
* int next = compute(current);
* if (count.commit(current, next))
* return true;
* else if (Thread.interrupted())
* throw new InterruptedException();
* }
* return false;
* }
* int compute(int l) { ... some kind of computation ... }
* }
*
* *
swap method that atomically swaps with another
* object of the same class using a deadlock-avoidance strategy.
* *
* Guarded methods
* All Waitable subclasses provide notifications on
* every value update, and support guarded methods of the form
* whenpredicate, that wait until the
* predicate hold, then optionally run any Runnable action
* within the lock, and then return. All types support:
*
* Other methods
* This class implements Executor, and provides an execute
* method that runs the runnable within the lock.
*
* All classes except SynchronizedRef and WaitableRef implement
* Cloneable and Comparable.
* Implementations of the corresponding
* methods either use default mechanics, or use methods that closely
* correspond to their java.lang analogs. SynchronizedRef does not
* implement any of these standard interfaces because there are
* many cases where it would not make sense. However, you can
* easily make simple subclasses that add the appropriate declarations.
*
*
* * * *
[ Introduction to this package. ] **/ public class SynchronizedVariable implements Executor { protected final Object lock_; /** Create a SynchronizedVariable using the supplied lock **/ public SynchronizedVariable(Object lock) { lock_ = lock; } /** Create a SynchronizedVariable using itself as the lock **/ public SynchronizedVariable() { lock_ = this; } /** * Return the lock used for all synchronization for this object **/ public Object getLock() { return lock_; } /** * If current thread is not interrupted, execute the given command * within this object's lock **/ public void execute(Runnable command) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); synchronized (lock_) { command.run(); } } } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/Takable.java 0000644 0001750 0001750 00000004500 10730503124 027366 0 ustar twerner twerner /* File: Takable.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 11Jun1998 dl Create public version */ package org.logicalcobwebs.concurrent; /** * This interface exists to enable stricter type checking * for channels. A method argument or instance variable * in a consumer object can be declared as only a Takable * rather than a Channel, in which case a Java compiler * will disallow put operations. *
* Full method descriptions appear in the Channel interface. *
[ Introduction to this package. ] * @see Channel * @see Puttable **/ public interface Takable { /** * Return and remove an item from channel, * possibly waiting indefinitely until * such an item exists. * @return some item from the channel. Different implementations * may guarantee various properties (such as FIFO) about that item * @exception InterruptedException if the current thread has * been interrupted at a point at which interruption * is detected, in which case state of the channel is unchanged. * **/ public Object take() throws InterruptedException; /** * Return and remove an item from channel only if one is available within * msecs milliseconds. The time bound is interpreted in a coarse * grained, best-effort fashion. * @param msecs the number of milliseconds to wait. If less than * or equal to zero, the operation does not perform any timed waits, * but might still require * access to a synchronization lock, which can impose unbounded * delay if there is a lot of contention for the channel. * @return some item, or null if the channel is empty. * @exception InterruptedException if the current thread has * been interrupted at a point at which interruption * is detected, in which case state of the channel is unchanged * (i.e., equivalent to a false return). **/ public Object poll(long msecs) throws InterruptedException; } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/TimeoutException.java 0000644 0001750 0001750 00000002602 10730503124 031331 0 ustar twerner twerner /* File: TimeoutException.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 29Jun1998 dl Create public version 4Aug1998 dl Change to extend InterruptedException */ package org.logicalcobwebs.concurrent; /** * Thrown by synchronization classes that report * timeouts via exceptions. The exception is treated * as a form (subclass) of InterruptedException. This both * simplifies handling, and conceptually reflects the fact that * timed-out operations are artificially interrupted by timers. **/ public class TimeoutException extends InterruptedException { /** * The approximate time that the operation lasted before * this timeout exception was thrown. **/ public final long duration; /** * Constructs a TimeoutException with given duration value. **/ public TimeoutException(long time) { duration = time; } /** * Constructs a TimeoutException with the * specified duration value and detail message. */ public TimeoutException(long time, String message) { super(message); duration = time; } } ././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/WriterPreferenceReadWriteLock.java libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/WriterPreferenceReadWriteLock.java0000644 0001750 0001750 00000025244 10730503124 033726 0 ustar twerner twerner /* File: WriterPreferenceReadWriteLock.java Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code. History: Date Who What 11Jun1998 dl Create public version 5Aug1998 dl replaced int counters with longs 25aug1998 dl record writer thread 3May1999 dl add notifications on interrupt/timeout */ package org.logicalcobwebs.concurrent; /** * A ReadWriteLock that prefers waiting writers over * waiting readers when there is contention. This class * is adapted from the versions described in CPJ, improving * on the ones there a bit by segregating reader and writer * wait queues, which is typically more efficient. *
* The locks are NOT reentrant. In particular, * even though it may appear to usually work OK, * a thread holding a read lock should not attempt to * re-acquire it. Doing so risks lockouts when there are * also waiting writers. *
[ Introduction to this package. ] **/ public class WriterPreferenceReadWriteLock implements ReadWriteLock { protected long activeReaders_ = 0; protected Thread activeWriter_ = null; protected long waitingReaders_ = 0; protected long waitingWriters_ = 0; protected final ReaderLock readerLock_ = new ReaderLock(); protected final WriterLock writerLock_ = new WriterLock(); public Sync writeLock() { return writerLock_; } public Sync readLock() { return readerLock_; } /* A bunch of small synchronized methods are needed to allow communication from the Lock objects back to this object, that serves as controller */ protected synchronized void cancelledWaitingReader() { --waitingReaders_; } protected synchronized void cancelledWaitingWriter() { --waitingWriters_; } /** Override this method to change to reader preference **/ protected boolean allowReader() { return activeWriter_ == null && waitingWriters_ == 0; } protected synchronized boolean startRead() { boolean allowRead = allowReader(); if (allowRead) ++activeReaders_; return allowRead; } protected synchronized boolean startWrite() { // The allowWrite expression cannot be modified without // also changing startWrite, so is hard-wired boolean allowWrite = (activeWriter_ == null && activeReaders_ == 0); if (allowWrite) activeWriter_ = Thread.currentThread(); return allowWrite; } /* Each of these variants is needed to maintain atomicity of wait counts during wait loops. They could be made faster by manually inlining each other. We hope that compilers do this for us though. */ protected synchronized boolean startReadFromNewReader() { boolean pass = startRead(); if (!pass) ++waitingReaders_; return pass; } protected synchronized boolean startWriteFromNewWriter() { boolean pass = startWrite(); if (!pass) ++waitingWriters_; return pass; } protected synchronized boolean startReadFromWaitingReader() { boolean pass = startRead(); if (pass) --waitingReaders_; return pass; } protected synchronized boolean startWriteFromWaitingWriter() { boolean pass = startWrite(); if (pass) --waitingWriters_; return pass; } /** * Called upon termination of a read. * Returns the object to signal to wake up a waiter, or null if no such **/ protected synchronized Signaller endRead() { if (--activeReaders_ == 0 && waitingWriters_ > 0) return writerLock_; else return null; } /** * Called upon termination of a write. * Returns the object to signal to wake up a waiter, or null if no such **/ protected synchronized Signaller endWrite() { activeWriter_ = null; if (waitingReaders_ > 0 && allowReader()) return readerLock_; else if (waitingWriters_ > 0) return writerLock_; else return null; } /** * Reader and Writer requests are maintained in two different * wait sets, by two different objects. These objects do not * know whether the wait sets need notification since they * don't know preference rules. So, each supports a * method that can be selected by main controlling object * to perform the notifications. This base class simplifies mechanics. **/ protected abstract class Signaller { // base for ReaderLock and WriterLock abstract void signalWaiters(); } protected class ReaderLock extends Signaller implements Sync { public void acquire() throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); InterruptedException ie = null; synchronized (this) { if (!startReadFromNewReader()) { for (; ;) { try { ReaderLock.this.wait(); if (startReadFromWaitingReader()) return; } catch (InterruptedException ex) { cancelledWaitingReader(); ie = ex; break; } } } } if (ie != null) { // fall through outside synch on interrupt. // This notification is not really needed here, // but may be in plausible subclasses writerLock_.signalWaiters(); throw ie; } } public void release() { Signaller s = endRead(); if (s != null) s.signalWaiters(); } synchronized void signalWaiters() { ReaderLock.this.notifyAll(); } public boolean attempt(long msecs) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); InterruptedException ie = null; synchronized (this) { if (msecs <= 0) return startRead(); else if (startReadFromNewReader()) return true; else { long waitTime = msecs; long start = System.currentTimeMillis(); for (; ;) { try { ReaderLock.this.wait(waitTime); } catch (InterruptedException ex) { cancelledWaitingReader(); ie = ex; break; } if (startReadFromWaitingReader()) return true; else { waitTime = msecs - (System.currentTimeMillis() - start); if (waitTime <= 0) { cancelledWaitingReader(); break; } } } } } // safeguard on interrupt or timeout: writerLock_.signalWaiters(); if (ie != null) throw ie; else return false; // timed out } } protected class WriterLock extends Signaller implements Sync { public void acquire() throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); InterruptedException ie = null; synchronized (this) { if (!startWriteFromNewWriter()) { for (; ;) { try { WriterLock.this.wait(); if (startWriteFromWaitingWriter()) return; } catch (InterruptedException ex) { cancelledWaitingWriter(); WriterLock.this.notify(); ie = ex; break; } } } } if (ie != null) { // Fall through outside synch on interrupt. // On exception, we may need to signal readers. // It is not worth checking here whether it is strictly necessary. readerLock_.signalWaiters(); throw ie; } } public void release() { Signaller s = endWrite(); if (s != null) s.signalWaiters(); } synchronized void signalWaiters() { WriterLock.this.notify(); } public boolean attempt(long msecs) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); InterruptedException ie = null; synchronized (this) { if (msecs <= 0) return startWrite(); else if (startWriteFromNewWriter()) return true; else { long waitTime = msecs; long start = System.currentTimeMillis(); for (; ;) { try { WriterLock.this.wait(waitTime); } catch (InterruptedException ex) { cancelledWaitingWriter(); WriterLock.this.notify(); ie = ex; break; } if (startWriteFromWaitingWriter()) return true; else { waitTime = msecs - (System.currentTimeMillis() - start); if (waitTime <= 0) { cancelledWaitingWriter(); WriterLock.this.notify(); break; } } } } } readerLock_.signalWaiters(); if (ie != null) throw ie; else return false; // timed out } } } libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/concurrent/package.html 0000644 0001750 0001750 00000000554 10730503124 027446 0 ustar twerner twerner
Concurrency utilities.
Originally written by Doug Lea and released into the public domain. This may be used for any purposes whatsoever without acknowledgment. Thanks for the assistance and support of Sun Microsystems Labs, and everyone contributing, testing, and using this code.
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ 0000755 0001750 0001750 00000000000 11054125603 024503 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/ 0000755 0001750 0001750 00000000000 11054125603 025573 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/jmx/ 0000755 0001750 0001750 00000000000 11054125603 026371 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/jmx/ConnectionPoolMBean.java 0000644 0001750 0001750 00000114606 10730503124 033076 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.admin.jmx; import org.logicalcobwebs.proxool.resources.ResourceNamesIF; import org.logicalcobwebs.proxool.ProxoolConstants; import org.logicalcobwebs.proxool.ConnectionPoolDefinitionIF; import org.logicalcobwebs.proxool.ProxoolFacade; import org.logicalcobwebs.proxool.ProxoolException; import org.logicalcobwebs.proxool.ProxoolListenerIF; import org.logicalcobwebs.proxool.ConfigurationListenerIF; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import javax.management.MBeanInfo; import javax.management.MBeanOperationInfo; import javax.management.MBeanConstructorInfo; import javax.management.MBeanAttributeInfo; import javax.management.MBeanNotificationInfo; import javax.management.DynamicMBean; import javax.management.AttributeNotFoundException; import javax.management.MBeanException; import javax.management.ReflectionException; import javax.management.RuntimeOperationsException; import javax.management.Attribute; import javax.management.InvalidAttributeValueException; import javax.management.AttributeList; import javax.management.MBeanParameterInfo; import javax.management.NotificationBroadcaster; import javax.management.NotificationBroadcasterSupport; import javax.management.NotificationListener; import javax.management.NotificationFilter; import javax.management.ListenerNotFoundException; import javax.management.Notification; import javax.management.MBeanRegistration; import javax.management.ObjectName; import javax.management.MBeanServer; import java.util.Iterator; import java.util.ResourceBundle; import java.util.Properties; import java.util.StringTokenizer; import java.text.MessageFormat; /** * JMX DynamicMBean adapter for a Proxool connection pool.* Attributes *
* Operations *
* Notifications *
-<char> to
* <uppercase char>.driver-properties will for instance become
* driverProperties.
* @param propertyName the name to be converted.
* @return the converted attribute name.
*/
public static String getValidIdentifier(String propertyName) {
if (propertyName.indexOf("-") == -1) {
return propertyName;
} else {
StringBuffer buffer = new StringBuffer (propertyName);
int index = -1;
while ((index = buffer.toString().indexOf("-")) > -1) {
buffer.deleteCharAt(index);
buffer.setCharAt(index, Character.toUpperCase(buffer.charAt(index)));
}
return buffer.toString();
}
}
}
/*
Revision history:
$Log: ProxoolJMXHelper.java,v $
Revision 1.7 2006/01/18 14:39:56 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.6 2003/05/06 23:15:56 chr32
Moving JMX classes back in from sandbox.
Revision 1.1 2003/03/07 16:35:18 billhorsman
moved jmx stuff into sandbox until it is tested
Revision 1.4 2003/03/05 15:14:15 billhorsman
fix for jdk 1.2
Revision 1.3 2003/03/03 11:12:00 billhorsman
fixed licence
Revision 1.2 2003/02/26 19:05:03 chr32
Added utility methods.
Fixed mutiple servers bug.
Revision 1.1 2003/02/24 18:01:29 chr32
Rewrite and renamed: ProxoolJMXHelper.
Revision 1.1 2003/02/24 01:14:17 chr32
Init rev (unfinished).
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/jmx/package.html 0000644 0001750 0001750 00000000354 10730503124 030652 0 ustar twerner twerner
Contains an MBean adapter to manage pools through JMX plus a utility to register/deregister these beans. See the
configuration documentation to learn how to activate a pool for JMX. No programming is necessary to do this.
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/jndi/ 0000755 0001750 0001750 00000000000 11054125603 026517 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/jndi/ProxoolJNDIHelper.java 0000644 0001750 0001750 00000004132 10730503124 032627 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool.admin.jndi;
import org.logicalcobwebs.proxool.ProxoolConstants;
import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.ProxoolDataSource;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import java.util.Properties;
/**
* Utilities for Proxool JNDI operations.
* @version $Revision: 1.3 $, $Date: 2004/06/17 21:33:12 $
* @author Christian Nedregaard (christian_nedregaard@email.com)
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.9
*/
public class ProxoolJNDIHelper {
private ProxoolJNDIHelper() {
}
/**
* Create a {@link org.logicalcobwebs.proxool.ProxoolDataSource} with the given alias
* and bind it to JNDI using the given jndi properties.
* @param jndiProperties the jndi related configuration properties.
* @throws ProxoolException if the JNDI binding failes.
*/
public static void registerDatasource(String alias, Properties jndiProperties) throws ProxoolException {
DataSource dataSource = new ProxoolDataSource(alias);
final String jndiName = jndiProperties.getProperty(ProxoolConstants.JNDI_NAME);
jndiProperties.remove(ProxoolConstants.JNDI_NAME);
try {
InitialContext initalContext = new InitialContext(jndiProperties);
initalContext.rebind(jndiName, dataSource);
} catch (NamingException e) {
throw new ProxoolException("JNDI binding of DataSource for alias " + alias
+ " failed.", e);
}
}
}
/*
Revision history:
$Log: ProxoolJNDIHelper.java,v $
Revision 1.3 2004/06/17 21:33:12 billhorsman
JavaDoc fix
Revision 1.2 2004/03/18 17:13:48 chr32
Started using ProxoolDataSource instead of ProxoolManagedDataSource.
Revision 1.1 2004/03/15 02:47:02 chr32
Added initial DataSource support.
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/jndi/package.html 0000644 0001750 0001750 00000000330 10730503124 030772 0 ustar twerner twerner
Contains a helper that can create a Proxool datasource and bind it to JNDI.
See the configuration documentation to learn how to register a DataSource for a pool.
No programming is necessary to do this.
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/servlet/ 0000755 0001750 0001750 00000000000 11054125603 027257 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/servlet/AdminServlet.java 0000644 0001750 0001750 00000117073 10730607711 032535 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool.admin.servlet;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.*;
import org.logicalcobwebs.proxool.admin.SnapshotIF;
import org.logicalcobwebs.proxool.admin.StatisticsIF;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.Properties;
/**
* Use this to admin each pool within Proxool. It acts like a normal
* servlet., so just configure it within your web app as you see fit.
* For example, within web.xml:
* * <servlet> * <servlet-name>Admin</servlet-name> * <servlet-class>org.logicalcobwebs.proxool.admin.servlet.AdminServlet</servlet-class> * <init-param> * <param-name>output</param-name> * <param-value>full|simple</param-value> * </init-param> * <init-param> * <param-name>cssFile</param-name> * <param-value>/my_path/my.css</param-value> * </init-param> * </servlet> * <servlet-mapping> * <servlet-name>Admin</servlet-name> * <url-pattern>/proxool</url-pattern> * </servlet-mapping> ** * Options: *
| "); } } out.append(" |
| # | "); out.print("born | "); out.print("last start | ");
out.print("lap (ms) | ");
out.print("thread | "); out.print("
| "); out.print(connectionInfo.getId()); } else { out.print("border: 1px solid transparent;"); out.print("\">"); out.print(connectionInfo.getId()); out.print(""); } out.print(" | "); // birth out.print(""); out.print(TIME_FORMAT.format(connectionInfo.getBirthDate())); out.print(" | "); // started out.print(""); out.print(connectionInfo.getTimeLastStartActive() > 0 ? TIME_FORMAT.format(new Date(connectionInfo.getTimeLastStartActive())) : "-"); out.print(" | "); // active out.print(""); String active = " "; if (connectionInfo.getTimeLastStopActive() > 0) { active = String.valueOf((int) (connectionInfo.getTimeLastStopActive() - connectionInfo.getTimeLastStartActive())); } else if (connectionInfo.getTimeLastStartActive() > 0) { active = String.valueOf((int) (snapshot.getSnapshotDate().getTime() - connectionInfo.getTimeLastStartActive())); } out.print(active); out.print(" | "); // requester out.print(""); out.print(connectionInfo.getRequester() != null ? connectionInfo.getRequester() : "-"); out.print(" | "); out.println("
No pools have been registered.
"); } else if (aliases.length == 1) { // Don't bother listing. Just show it. } else { out.println(""); } } /** * Express time in an easy to read HH:mm:ss format * * @param time in milliseconds * @return time (e.g. 180000 = 00:30:00) * @see #TIME_FORMAT */ private String formatMilliseconds(long time) { if (time > Integer.MAX_VALUE) { return time + "ms"; } else { Calendar c = Calendar.getInstance(); c.clear(); c.add(Calendar.MILLISECOND, (int) time); return TIME_FORMAT.format(c.getTime()); } } } /* Revision history: $Log: AdminServlet.java,v $ Revision 1.16 2007/12/14 23:20:41 billhorsman Change date format to yyyy-MM-dd to avoid CharConversionException in some locales. Revision 1.15 2007/06/19 11:33:35 billhorsman Changed time (millisecond) properties from int to long: maximumConnectionLifetime, houseKeepingSleepTime, recentlyStartedThreshold, overloadWithoutRefusalLifetime, maximumActiveTime Revision 1.14 2006/06/09 17:32:54 billhorsman Fix closing tag for select. Credit to Paolo Di Tommaso. Revision 1.13 2006/01/18 14:39:56 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.12 2005/10/07 08:23:10 billhorsman Doc Revision 1.11 2005/10/02 09:45:49 billhorsman Layout Revision 1.10 2005/09/26 21:47:46 billhorsman no message Revision 1.9 2005/09/26 13:31:14 billhorsman Smartened up AdminServlet Revision 1.8 2003/09/29 17:49:19 billhorsman Includes new fatal-sql-exception-wrapper-class in display Revision 1.7 2003/08/06 20:08:58 billhorsman fix timezone display of time (for millisecond based properties) Revision 1.6 2003/03/10 23:43:14 billhorsman reapplied checkstyle that i'd inadvertently let IntelliJ change... Revision 1.5 2003/03/10 15:26:51 billhorsman refactoringn of concurrency stuff (and some import optimisation) Revision 1.4 2003/03/03 11:12:00 billhorsman fixed licence Revision 1.3 2003/02/26 16:59:18 billhorsman fixed spelling error in method name Revision 1.2 2003/02/26 16:51:12 billhorsman fixed units for average active time. now displays properly in seconds Revision 1.1 2003/02/24 10:19:44 billhorsman moved AdminServlet into servlet package Revision 1.1 2003/02/19 23:36:51 billhorsman renamed monitor package to admin Revision 1.10 2003/02/12 12:28:27 billhorsman added url, proxyHashcode and delegateHashcode to ConnectionInfoIF Revision 1.9 2003/02/11 00:30:28 billhorsman add version Revision 1.8 2003/02/06 17:41:05 billhorsman now uses imported logging Revision 1.7 2003/02/06 15:42:21 billhorsman display changes Revision 1.6 2003/02/05 17:04:02 billhorsman fixed date format Revision 1.5 2003/02/05 15:06:16 billhorsman removed dependency on JDK1.4 imaging. Revision 1.4 2003/01/31 16:53:21 billhorsman checkstyle Revision 1.3 2003/01/31 16:38:52 billhorsman doc (and removing public modifier for classes where possible) Revision 1.2 2003/01/31 11:35:57 billhorsman improvements to servlet (including connection details) Revision 1.1 2003/01/31 00:38:22 billhorsman *** empty log message *** */ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/servlet/package.html 0000644 0001750 0001750 00000001255 10730503124 031541 0 ustar twerner twernerThe AdminServlet provides information about running pools. This is only relevant if you are using Proxool inside a web application. You can configure the servlet in any way you like, but this is an example web.xml fragment:
<servlet>
<servlet-name>Monitor</servlet-name>
<servlet-class>org.logicalcobwebs.proxool.admin.servlet.AdminServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Monitor</servlet-name>
<url-pattern>/monitor</url-pattern>
</servlet-mapping>
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/Admin.java 0000644 0001750 0001750 00000020020 10730503125 027457 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool.admin;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.ConnectionPoolDefinitionIF;
import org.logicalcobwebs.proxool.ConnectionPoolStatisticsIF;
import org.logicalcobwebs.proxool.ProxoolException;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.Vector;
/**
* Provides statistics about the performance of a pool.
*
* @version $Revision: 1.9 $, $Date: 2006/01/18 14:39:57 $
* @author bill
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.7
*/
public class Admin {
private static final Log LOG = LogFactory.getLog(Admin.class);
private Log log;
private Map statsRollers = new HashMap();
private CompositeStatisticsListener compositeStatisticsListener = new CompositeStatisticsListener();
/**
* @param definition gives access to pool definition
* @param definition see {@link org.logicalcobwebs.proxool.ConnectionPoolDefinitionIF#getStatistics definition}
*/
public Admin(ConnectionPoolDefinitionIF definition) throws ProxoolException {
log = LogFactory.getLog("org.logicalcobwebs.proxool.stats." + definition.getAlias());
StringTokenizer st = new StringTokenizer(definition.getStatistics(), ",");
while (st.hasMoreTokens()) {
String token = st.nextToken();
statsRollers.put(token, new StatsRoller(definition.getAlias(), compositeStatisticsListener, token));
}
if (definition.getStatisticsLogLevel() != null) {
compositeStatisticsListener.addListener(new StatisticsLogger(log, definition.getStatisticsLogLevel()));
}
}
public void addStatisticsListener(StatisticsListenerIF statisticsListener) {
this.compositeStatisticsListener.addListener(statisticsListener);
}
/**
* Call this every time an active connection is returned to the pool
* @param activeTime how long the connection was active
*/
public void connectionReturned(long activeTime) {
try {
Iterator i = statsRollers.values().iterator();
while (i.hasNext()) {
StatsRoller statsRoller = (StatsRoller) i.next();
statsRoller.connectionReturned(activeTime);
}
} catch (Throwable e) {
LOG.error("Stats connectionReturned call failed. Ignoring.", e);
}
}
/**
* Call this every time a connection is refused
*/
public void connectionRefused() {
try {
Iterator i = statsRollers.values().iterator();
while (i.hasNext()) {
StatsRoller statsRoller = (StatsRoller) i.next();
statsRoller.connectionRefused();
}
} catch (Exception e) {
LOG.error("Stats connectionRefused call failed. Ignoring.", e);
}
}
/**
* Returns the most recent sample that has completed its period
* @return sample (or null if no statistics are complete yet)
*/
public StatisticsIF getStatistics(String token) {
try {
return ((StatsRoller) statsRollers.get(token)).getCompleteStatistics();
} catch (NullPointerException e) {
return null;
}
}
/**
* Cancels the timer that outputs the stats
*/
public void cancelAll() {
Iterator i = statsRollers.values().iterator();
while (i.hasNext()) {
StatsRoller statsRoller = (StatsRoller) i.next();
statsRoller.cancel();
}
}
public StatisticsIF[] getStatistics() {
List statistics = new Vector();
Iterator i = statsRollers.values().iterator();
while (i.hasNext()) {
StatsRoller statsRoller = (StatsRoller) i.next();
StatisticsIF s = statsRoller.getCompleteStatistics();
if (s != null) {
statistics.add(s);
}
}
return (StatisticsIF[]) statistics.toArray(new StatisticsIF[statistics.size()]);
}
/**
* Get a new snapshot
* @param cps used to help populate the snapshot
* @param cpd used to help populate the snapshot
* @return snapshot
*/
public static SnapshotIF getSnapshot(ConnectionPoolStatisticsIF cps, ConnectionPoolDefinitionIF cpd, Collection connectionInfos) {
Snapshot s = new Snapshot(new Date());
s.setDateStarted(cps.getDateStarted());
s.setActiveConnectionCount(cps.getActiveConnectionCount());
s.setAvailableConnectionCount(cps.getAvailableConnectionCount());
s.setOfflineConnectionCount(cps.getOfflineConnectionCount());
s.setMaximumConnectionCount(cpd.getMaximumConnectionCount());
s.setServedCount(cps.getConnectionsServedCount());
s.setRefusedCount(cps.getConnectionsRefusedCount());
s.setConnectionInfos(connectionInfos);
s.setConnectionCount(cps.getConnectionCount());
/*
if (s.getActiveConnectionCount() != getCount(s.getConnectionInfos(), ConnectionInfoIF.STATUS_ACTIVE)) {
LOG.error("activeCount disparity: " + s.getActiveConnectionCount() + " != " + getCount(s.getConnectionInfos(), ConnectionInfoIF.STATUS_ACTIVE));
}
if (s.getAvailableConnectionCount() != getCount(s.getConnectionInfos(), ConnectionInfoIF.STATUS_AVAILABLE)) {
LOG.error("activeCount disparity: " + s.getAvailableConnectionCount() + " != " + getCount(s.getConnectionInfos(), ConnectionInfoIF.STATUS_AVAILABLE));
}
if (s.getOfflineConnectionCount() != getCount(s.getConnectionInfos(), ConnectionInfoIF.STATUS_OFFLINE)) {
LOG.error("offlineCount disparity: " + s.getOfflineConnectionCount() + " != " + getCount(s.getConnectionInfos(), ConnectionInfoIF.STATUS_OFFLINE));
}
*/
return s;
}
}
/*
Revision history:
$Log: Admin.java,v $
Revision 1.9 2006/01/18 14:39:57 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.8 2005/10/02 12:32:01 billhorsman
Make connectionCount available to statistics
Revision 1.7 2003/10/27 20:26:19 billhorsman
connectionReturned() and connectionRefused() calls will now log any errors and continue rather than
possibly throwing RuntimeExceptions back to the caller. In principle, stats should not cause problems
to the core code. (No evidence of this happening - but it's more robust now.)
Revision 1.6 2003/08/30 14:54:04 billhorsman
Checkstyle
Revision 1.5 2003/03/11 14:51:55 billhorsman
more concurrency fixes relating to snapshots
Revision 1.4 2003/03/10 23:43:14 billhorsman
reapplied checkstyle that i'd inadvertently let
IntelliJ change...
Revision 1.3 2003/03/10 15:26:50 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.2 2003/03/03 11:11:58 billhorsman
fixed licence
Revision 1.1 2003/02/19 23:36:51 billhorsman
renamed monitor package to admin
Revision 1.8 2003/02/07 15:08:51 billhorsman
removed redundant accessor
Revision 1.7 2003/02/07 14:16:45 billhorsman
support for StatisticsListenerIF
Revision 1.6 2003/02/06 17:41:05 billhorsman
now uses imported logging
Revision 1.5 2003/02/05 00:20:27 billhorsman
getSnapshot is now static (because it can be)
Revision 1.4 2003/02/04 15:59:49 billhorsman
finalize now shuts down StatsRoller timer
Revision 1.3 2003/01/31 16:53:21 billhorsman
checkstyle
Revision 1.2 2003/01/31 16:38:51 billhorsman
doc (and removing public modifier for classes where possible)
Revision 1.1 2003/01/31 11:35:57 billhorsman
improvements to servlet (including connection details)
Revision 1.2 2003/01/31 00:28:57 billhorsman
now handles multiple statistics
Revision 1.1 2003/01/30 17:20:19 billhorsman
fixes, improvements and doc
*/ ././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/CompositeStatisticsListener.java libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/CompositeStatisticsListener.jav0000644 0001750 0001750 00000005173 10730503125 034025 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool.admin;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.util.AbstractListenerContainer;
/**
* A {@link StatisticsListenerIF} that keeps a list of StatisticsListenerIFs
* and notifies them in a thread safe manner.
* It also implements {@link org.logicalcobwebs.proxool.util.ListenerContainerIF ListenerContainerIF}
* which provides methods for
* {@link org.logicalcobwebs.proxool.util.ListenerContainerIF#addListener(Object) adding} and
* {@link org.logicalcobwebs.proxool.util.ListenerContainerIF#removeListener(Object) removing} listeners.
*
* @version $Revision: 1.5 $, $Date: 2006/01/18 14:39:57 $
* @author Christian Nedregaard (christian_nedregaard@email.com)
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.7
*/
public class CompositeStatisticsListener extends AbstractListenerContainer implements StatisticsListenerIF {
static final Log LOG = LogFactory.getLog(CompositeStatisticsListener.class);
/**
* @see StatisticsListenerIF#statistics(String, StatisticsIF)
*/
public void statistics(String alias, StatisticsIF statistics)
{
Object[] listeners = getListeners();
for(int i=0; i
* String alias = "myPool";
* StatisticsListenerIF myStatisticsListener = new MyStatisticsListener();
* ProxoolFacade.{@link org.logicalcobwebs.proxool.ProxoolFacade#addStatisticsListener addStatisticsListener}(alias, myStatisticsListener);
*
* @version $Revision: 1.2 $, $Date: 2003/03/03 11:11:59 $
* @author bill
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.7
*/
public interface StatisticsListenerIF {
/**
* A new set of statistics have just been produced
* @param alias identifies the pool
* @param statistics new statistics
*/
void statistics(String alias, StatisticsIF statistics);
}
/*
Revision history:
$Log: StatisticsListenerIF.java,v $
Revision 1.2 2003/03/03 11:11:59 billhorsman
fixed licence
Revision 1.1 2003/02/19 23:36:51 billhorsman
renamed monitor package to admin
Revision 1.2 2003/02/08 00:35:29 billhorsman
doc
Revision 1.1 2003/01/31 15:16:12 billhorsman
new listener
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/StatisticsLogger.java 0000644 0001750 0001750 00000005550 10730503124 031733 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool.admin;
import org.apache.commons.logging.Log;
import org.logicalcobwebs.proxool.ProxoolConstants;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
/**
* Listens to statistics and logs them
* @version $Revision: 1.3 $, $Date: 2006/01/18 14:39:57 $
* @author bill
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.7
*/
public class StatisticsLogger implements StatisticsListenerIF {
private static final DecimalFormat DECIMAL_FORMAT = new DecimalFormat("0.00");
private static final DateFormat TIME_FORMAT = new SimpleDateFormat("HH:mm:ss");
private Log log;
private String logLevel;
public StatisticsLogger(Log log, String logLevel) {
this.log = log;
this.logLevel = logLevel;
}
public void statistics(String alias, StatisticsIF statistics) {
if (statistics != null && logLevel != null) {
StringBuffer out = new StringBuffer();
out.append(TIME_FORMAT.format(statistics.getStartDate()));
out.append(" - ");
out.append(TIME_FORMAT.format(statistics.getStopDate()));
out.append(", s:");
out.append(statistics.getServedCount());
out.append(":");
out.append(DECIMAL_FORMAT.format(statistics.getServedPerSecond()));
out.append("/s, r:");
out.append(statistics.getRefusedCount());
out.append(":");
out.append(DECIMAL_FORMAT.format(statistics.getRefusedPerSecond()));
out.append("/s, a:");
out.append(DECIMAL_FORMAT.format(statistics.getAverageActiveTime()));
out.append("ms/");
out.append(DECIMAL_FORMAT.format(statistics.getAverageActiveCount()));
if (logLevel.equals(ProxoolConstants.STATISTICS_LOG_LEVEL_TRACE)) {
log.trace(out.toString());
} else if (logLevel.equals(ProxoolConstants.STATISTICS_LOG_LEVEL_DEBUG)) {
log.debug(out.toString());
} else if (logLevel.equals(ProxoolConstants.STATISTICS_LOG_LEVEL_INFO)) {
log.info(out.toString());
}
}
}
}
/*
Revision history:
$Log: StatisticsLogger.java,v $
Revision 1.3 2006/01/18 14:39:57 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.2 2003/03/03 11:11:59 billhorsman
fixed licence
Revision 1.1 2003/02/19 23:36:51 billhorsman
renamed monitor package to admin
Revision 1.1 2003/02/07 14:16:46 billhorsman
support for StatisticsListenerIF
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/StatsRoller.java 0000644 0001750 0001750 00000017346 10730503124 030725 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool.admin;
import org.logicalcobwebs.concurrent.WriterPreferenceReadWriteLock;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.ProxoolException;
import java.util.Calendar;
/**
* Responsbile for a single set of statistics. It rolls over to a new set
* whenever it should. It provides access to the latest complete set
* when it is available.
*
* @version $Revision: 1.9 $, $Date: 2006/01/18 14:39:58 $
* @author bill
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.7
*/
class StatsRoller {
private static final Log LOG = LogFactory.getLog(StatsRoller.class);
private WriterPreferenceReadWriteLock readWriteLock = new WriterPreferenceReadWriteLock();
private Statistics completeStatistics;
private Statistics currentStatistics;
private Calendar nextRollDate;
private int period;
private int units;
private boolean running = true;
private CompositeStatisticsListener compositeStatisticsListener;
private String alias;
public StatsRoller(String alias, CompositeStatisticsListener compositeStatisticsListener, String token) throws ProxoolException {
this.alias = alias;
this.compositeStatisticsListener = compositeStatisticsListener;
nextRollDate = Calendar.getInstance();
if (token.endsWith("s")) {
units = Calendar.SECOND;
nextRollDate.clear(Calendar.SECOND);
nextRollDate.clear(Calendar.MILLISECOND);
} else if (token.endsWith("m")) {
units = Calendar.MINUTE;
nextRollDate.clear(Calendar.MINUTE);
nextRollDate.clear(Calendar.SECOND);
nextRollDate.clear(Calendar.MILLISECOND);
} else if (token.endsWith("h")) {
nextRollDate.clear(Calendar.HOUR_OF_DAY);
nextRollDate.clear(Calendar.MINUTE);
nextRollDate.clear(Calendar.SECOND);
nextRollDate.clear(Calendar.MILLISECOND);
units = Calendar.HOUR_OF_DAY;
} else if (token.endsWith("d")) {
units = Calendar.DATE;
nextRollDate.clear(Calendar.HOUR_OF_DAY);
nextRollDate.clear(Calendar.MINUTE);
nextRollDate.clear(Calendar.SECOND);
nextRollDate.clear(Calendar.MILLISECOND);
} else {
throw new ProxoolException("Unrecognised suffix in statistics: " + token);
}
period = Integer.parseInt(token.substring(0, token.length() - 1));
// Now roll forward until you get one step into the future
Calendar now = Calendar.getInstance();
while (nextRollDate.before(now)) {
nextRollDate.add(units, period);
}
LOG.debug("Collecting first statistics for '" + token + "' at " + nextRollDate.getTime());
currentStatistics = new Statistics(now.getTime());
// Automatically trigger roll if no activity
final Thread t = new Thread() {
public void run() {
while (running) {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
LOG.debug("Interruption", e);
}
roll();
}
}
};
t.setDaemon(true);
t.start();
}
/**
* Cancels the timer that outputs the stats
*/
protected void cancel() {
running = false;
}
private void roll() {
if (!isCurrent()) {
try {
readWriteLock.writeLock().acquire();
if (!isCurrent()) {
currentStatistics.setStopDate(nextRollDate.getTime());
completeStatistics = currentStatistics;
currentStatistics = new Statistics(nextRollDate.getTime());
nextRollDate.add(units, period);
compositeStatisticsListener.statistics(alias, completeStatistics);
}
} catch (Throwable e) {
LOG.error("Unable to roll statistics log", e);
} finally {
readWriteLock.writeLock().release();
}
}
}
private boolean isCurrent() {
return (System.currentTimeMillis() < nextRollDate.getTime().getTime());
}
/**
* @see org.logicalcobwebs.proxool.admin.Admin#connectionReturned
*/
public void connectionReturned(long activeTime) {
roll();
try {
readWriteLock.readLock().acquire();
currentStatistics.connectionReturned(activeTime);
} catch (InterruptedException e) {
LOG.error("Unable to log connectionReturned", e);
} finally {
readWriteLock.readLock().release();
}
}
/**
* @see org.logicalcobwebs.proxool.admin.Admin#connectionRefused
*/
public void connectionRefused() {
roll();
try {
readWriteLock.readLock().acquire();
currentStatistics.connectionRefused();
} catch (InterruptedException e) {
LOG.error("Unable to log connectionRefused", e);
} finally {
readWriteLock.readLock().release();
}
}
/**
*
* @return
*/
public Statistics getCompleteStatistics() {
try {
readWriteLock.readLock().acquire();
return completeStatistics;
} catch (InterruptedException e) {
LOG.error("Couldn't read statistics", e);
return null;
} finally {
readWriteLock.readLock().release();
}
}
}
/*
Revision history:
$Log: StatsRoller.java,v $
Revision 1.9 2006/01/18 14:39:58 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.8 2003/10/27 20:24:48 billhorsman
roll() now makes an additional call to isCurrent() *before* it asks for a write lock. Before it
was getting a write lock every five seconds which effectively blocks all connections (if only briefly).
Revision 1.7 2003/09/10 22:21:04 chr32
Removing > jdk 1.2 dependencies.
Revision 1.6 2003/03/11 00:12:11 billhorsman
switch to concurrent package
Revision 1.5 2003/03/06 21:56:27 billhorsman
remove too much debug
Revision 1.4 2003/03/06 12:44:02 billhorsman
add readWriteLock
Revision 1.3 2003/03/03 11:11:59 billhorsman
fixed licence
Revision 1.2 2003/02/28 12:42:45 billhorsman
removed unnecessary sleep in timer
Revision 1.1 2003/02/19 23:36:51 billhorsman
renamed monitor package to admin
Revision 1.11 2003/02/08 14:27:51 chr32
Style fixes.
Also tried to fix the dublicate linebreaks in the logging classes.
Revision 1.10 2003/02/07 14:16:46 billhorsman
support for StatisticsListenerIF
Revision 1.9 2003/02/06 17:41:06 billhorsman
now uses imported logging
Revision 1.8 2003/02/06 15:41:18 billhorsman
add statistics-log-level
Revision 1.7 2003/02/04 17:17:03 billhorsman
make Timer a daemon
Revision 1.6 2003/02/04 15:59:49 billhorsman
finalize now shuts down StatsRoller timer
Revision 1.5 2003/02/02 23:32:48 billhorsman
fixed bug caused by last variable name change. :(
Revision 1.4 2003/01/31 16:53:23 billhorsman
checkstyle
Revision 1.3 2003/01/31 16:38:54 billhorsman
doc (and removing public modifier for classes where possible)
Revision 1.2 2003/01/31 14:33:19 billhorsman
fix for DatabaseMetaData
Revision 1.1 2003/01/31 11:35:57 billhorsman
improvements to servlet (including connection details)
Revision 1.1 2003/01/31 00:28:57 billhorsman
now handles multiple statistics
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/admin/package.html 0000644 0001750 0001750 00000000406 10730503125 030053 0 ustar twerner twerner
Provides statistical information on each pool. Like:
* This is a "faceless" Avalon component. This means that it does not present an operational interface, it
* simply configures Proxool when Avalon calls its configure method. You need to lookup this
* component in your bootstrap code to make this happen.
*
* The configuration takes one attribute: close-on-dispose
*
* You can use this to let this configurator know
* wether or not to close the pools it has created
* when it is disposed.
*
Legal values are true or false. Default: true.
*
* See {@link XMLConfigurator} for the Proxool xml configuration format. *
*
* All the configure methods of this class takes a boolean argument describing whether the
* xml should be validated or not. If you want your xml to be validated be sure to read the
* Validation chapter in the JavaDoc for {@link XMLConfigurator}.
*
true if the parsel shall be validating, and false otherwise.
* @throws ProxoolException if the configuration fails.
*/
public static void configure(String xmlFileName, boolean validate) throws ProxoolException {
try {
if (LOG.isDebugEnabled()) {
LOG.debug("Configuring from xml file: " + xmlFileName);
}
configure(new InputSource(new FileReader(xmlFileName)), validate);
} catch (FileNotFoundException e) {
throw new ProxoolException(e);
}
}
/**
* Configure Proxool with xml from the given InputSource.
* @param inputSource the InputSource to read xml from.
* @param validate true if the parsel shall be validating, and false otherwise.
* @throws ProxoolException if the configuration fails.
*/
public static void configure(InputSource inputSource, boolean validate) throws ProxoolException {
try {
SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
if (LOG.isDebugEnabled()) {
LOG.debug("SAXParserFactory class: " + saxParserFactory.getClass().getName());
}
saxParserFactory.setValidating(validate);
final SAXParser saxParser = saxParserFactory.newSAXParser();
if (LOG.isDebugEnabled()) {
LOG.debug("sax parser class" + saxParser.getClass().getName());
}
final XMLReader xmlReader = saxParser.getXMLReader();
if (LOG.isDebugEnabled()) {
LOG.debug("XML reader class: " + xmlReader.getClass().getName());
}
final XMLConfigurator xmlConfigurator = new XMLConfigurator();
xmlReader.setErrorHandler(xmlConfigurator);
setSAXFeature(xmlReader, "http://xml.org/sax/features/namespaces", NAMESPACE_AWARE);
setSAXFeature(xmlReader, "http://xml.org/sax/features/namespace-prefixes", !NAMESPACE_AWARE);
saxParser.parse(inputSource, xmlConfigurator);
} catch (ParserConfigurationException pce) {
throw new ProxoolException("Parser configuration failed", pce);
} catch (SAXException se) {
throw new ProxoolException("Parsing failed.", se);
} catch (IOException ioe) {
throw new ProxoolException("Parsing failed.", ioe);
}
}
/**
* Configure Proxool with xml from the given reader.
* @param reader the reader to read xml from.
* @param validate true if the parsel shall be validating, and false otherwise.
* @throws ProxoolException if the configuration fails.
*/
public static void configure(Reader reader, boolean validate) throws ProxoolException {
if (LOG.isDebugEnabled()) {
LOG.debug("Configuring from reader: " + reader);
}
configure(new InputSource(reader), validate);
}
// only log warning on problems with recognition and support of features
// we'll probably pull through anyway...
private static void setSAXFeature(XMLReader xmlReader, String feature, boolean state) {
if (LOG.isDebugEnabled()) {
LOG.debug("Setting sax feature: '" + feature + "'. State: " + state + ".");
}
try {
xmlReader.setFeature(feature, state);
} catch (SAXNotRecognizedException e) {
LOG.warn("Feature: '" + feature + "' not recognised by xml reader " + xmlReader + ".", e);
} catch (SAXNotSupportedException e) {
LOG.warn("Feature: '" + feature + "' not supported by xml reader " + xmlReader + ".", e);
}
}
}
/*
Revision history:
$Log: JAXPConfigurator.java,v $
Revision 1.12 2006/01/18 14:39:58 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.11 2004/05/14 21:15:47 brenuart
Fix type in method name
Revision 1.10 2003/03/10 23:43:15 billhorsman
reapplied checkstyle that i'd inadvertently let
IntelliJ change...
Revision 1.9 2003/03/10 15:26:54 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.8 2003/03/03 11:12:00 billhorsman
fixed licence
Revision 1.7 2003/02/06 17:41:05 billhorsman
now uses imported logging
Revision 1.6 2003/01/27 18:26:42 billhorsman
refactoring of ProxyConnection and ProxyStatement to
make it easier to write JDK 1.2 patch
Revision 1.5 2002/12/18 23:31:57 chr32
Expanded doc.
Revision 1.4 2002/12/16 11:46:59 billhorsman
checkstyle
Revision 1.3 2002/12/16 02:38:47 chr32
Updated to new driver-properties xml format.
Revision 1.2 2002/12/15 19:43:11 chr32
Style fixes.
Revision 1.1 2002/12/15 18:49:55 chr32
Init rev.
*/ ././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/configuration/PropertyConfigurator.java libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/configuration/PropertyConfigurator.ja0000644 0001750 0001750 00000020413 10730503124 034073 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool.configuration;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.ProxoolConstants;
import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.ProxoolFacade;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
/**
* Uses a standard Java properties file to configure Proxool. For example:
*
* * jdbc-0.proxool.alias=property-test * jdbc-0.proxool.driver-url=jdbc:hsqldb:. * jdbc-0.proxool.driver-class=org.hsqldb.jdbcDriver * jdbc-0.user=foo * jdbc-0.password=bar * jdbc-0.proxool.house-keeping-sleep-time=40000 * jdbc-0.proxool.house-keeping-test-sql=select CURRENT_DATE * jdbc-0.proxool.maximum-connection-count=10 * jdbc-0.proxool.minimum-connection-count=3 * jdbc-0.proxool.maximum-connection-lifetime=18000000 * jdbc-0.proxool.simultaneous-build-throttle=5 * jdbc-0.proxool.recently-started-threshold=40000 * jdbc-0.proxool.overload-without-refusal-lifetime=50000 * jdbc-0.proxool.maximum-active-time=60000 * jdbc-0.proxool.verbose=true * jdbc-0.proxool.trace=true * jdbc-0.proxool.fatal-sql-exception=Fatal error * jdbc-0.proxool.prototype-count=2 * * jdbc-1.proxool.alias=property-test-2 * jdbc-1.proxool.driver-url=jdbc:hsqldb:. * jdbc-1.proxool.driver-class=org.hsqldb.jdbcDriver * jdbc-1.user=scott * jdbc-1.password=tiger * jdbc-1.proxool.house-keeping-sleep-time=40000 * jdbc-1.proxool.house-keeping-test-sql=select CURRENT_DATE * jdbc-1.proxool.maximum-connection-count=10 * jdbc-1.proxool.minimum-connection-count=3 * jdbc-1.proxool.maximum-connection-lifetime=18000000 * jdbc-1.proxool.simultaneous-build-throttle=5 * jdbc-1.proxool.recently-started-threshold=40000 * jdbc-1.proxool.overload-without-refusal-lifetime=50000 * jdbc-1.proxool.maximum-active-time=60000 * jdbc-1.proxool.verbose=true * jdbc-1.proxool.trace=true * jdbc-1.proxool.fatal-sql-exception=Fatal error * jdbc-1.proxool.prototype-count=2 ** *
The first word (up to the first dot) must start with "jdbc", but it can * be anything you like. Use unique names to identify each pool. Any property * not starting with "jdbc" will be ignored.
** The properties prefixed with "proxool." will be used by Proxool while * the properties that are not prefixed will be passed on to the * delegate JDBC driver. *
* * @version $Revision: 1.11 $, $Date: 2006/01/18 14:39:58 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ public class PropertyConfigurator { private static final Log LOG = LogFactory.getLog(PropertyConfigurator.class); protected static final String PREFIX = "jdbc"; private static final String DOT = "."; private static final String EXAMPLE_FORMAT = PREFIX + "*" + DOT + "*"; /** * Configure proxool with the given properties file. * @param filename the filename of the properties file. * @throws ProxoolException if the configuration fails. */ public static void configure(String filename) throws ProxoolException { Properties properties = new Properties(); try { properties.load(new FileInputStream(filename)); } catch (IOException e) { throw new ProxoolException("Couldn't load property file " + filename); } configure(properties); } /** * Configure proxool with the given properties. * @param properties the properties instance to use. * @throws ProxoolException if the configuration fails. */ public static void configure(Properties properties) throws ProxoolException { final Map propertiesMap = new HashMap(); final Iterator allPropertyKeysIterator = properties.keySet().iterator(); Properties proxoolProperties = null; while (allPropertyKeysIterator.hasNext()) { String key = (String) allPropertyKeysIterator.next(); String value = properties.getProperty(key); if (key.startsWith(PREFIX)) { int a = key.indexOf(DOT); if (a == -1) { throw new ProxoolException("Property " + key + " must be of the format " + EXAMPLE_FORMAT); } final String tag = key.substring(0, a); final String name = key.substring(a + 1); proxoolProperties = (Properties) propertiesMap.get(tag); if (proxoolProperties == null) { proxoolProperties = new Properties(); propertiesMap.put(tag, proxoolProperties); } proxoolProperties.put(name, value); } } final Iterator tags = propertiesMap.keySet().iterator(); while (tags.hasNext()) { proxoolProperties = (Properties) propertiesMap.get(tags.next()); // make sure that required propeties are defined // and build the url // Check that we have defined the minimum information final String driverClass = proxoolProperties.getProperty(ProxoolConstants.DRIVER_CLASS_PROPERTY); final String driverUrl = proxoolProperties.getProperty(ProxoolConstants.DRIVER_URL_PROPERTY); if (driverClass == null || driverUrl == null) { throw new ProxoolException("You must define the " + ProxoolConstants.DRIVER_CLASS_PROPERTY + " and the " + ProxoolConstants.DRIVER_URL_PROPERTY + "."); } final String alias = proxoolProperties.getProperty(ProxoolConstants.ALIAS_PROPERTY); // Build the URL; optionally defining a name StringBuffer url = new StringBuffer(); url.append("proxool"); if (alias != null) { url.append(ProxoolConstants.ALIAS_DELIMITER); url.append(alias); proxoolProperties.remove(ProxoolConstants.ALIAS_PROPERTY); } url.append(ProxoolConstants.URL_DELIMITER); url.append(driverClass); proxoolProperties.remove(ProxoolConstants.DRIVER_CLASS_PROPERTY); url.append(ProxoolConstants.URL_DELIMITER); url.append(driverUrl); proxoolProperties.remove(ProxoolConstants.DRIVER_URL_PROPERTY); if (LOG.isDebugEnabled()) { LOG.debug("Created url: " + url); } ProxoolFacade.registerConnectionPool(url.toString(), proxoolProperties); } } } /* Revision history: $Log: PropertyConfigurator.java,v $ Revision 1.11 2006/01/18 14:39:58 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.10 2003/03/05 23:28:56 billhorsman deprecated maximum-new-connections property in favour of more descriptive simultaneous-build-throttle Revision 1.9 2003/03/03 11:12:00 billhorsman fixed licence Revision 1.8 2003/02/06 17:41:05 billhorsman now uses imported logging Revision 1.7 2003/02/05 14:46:31 billhorsman fixed copyright and made PREFIX protected for use by ServletConfigurator Revision 1.6 2003/01/27 18:26:43 billhorsman refactoring of ProxyConnection and ProxyStatement to make it easier to write JDK 1.2 patch Revision 1.5 2003/01/23 10:41:05 billhorsman changed use of pool-name to alias for consistency Revision 1.4 2003/01/22 17:35:01 billhorsman checkstyle Revision 1.3 2003/01/18 15:13:12 billhorsman Signature changes (new ProxoolException thrown) on the ProxoolFacade API. Revision 1.2 2002/12/26 11:32:59 billhorsman Rewrote to support new format. Revision 1.1 2002/12/15 18:48:33 chr32 Movied in from 'ext' source tree. Revision 1.4 2002/11/09 15:57:57 billhorsman fix doc Revision 1.3 2002/11/02 14:22:16 billhorsman Documentation Revision 1.2 2002/10/27 13:05:01 billhorsman checkstyle Revision 1.1 2002/10/27 12:00:16 billhorsman moved classes from ext sub-package which is now obsolete - let's keep everything together in one place Revision 1.1 2002/10/25 10:40:27 billhorsman draft */ ././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/configuration/ServletConfigurator.java libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/configuration/ServletConfigurator.jav0000644 0001750 0001750 00000015515 10730503124 034070 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.configuration; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.logicalcobwebs.proxool.ProxoolException; import org.logicalcobwebs.proxool.ProxoolFacade; import javax.servlet.ServletConfig; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import java.io.File; import java.util.Enumeration; import java.util.Properties; /** *Allows you to configure Proxool using a servlet. There are three * different ways: * * The init parameters * can either directly configure Proxool (in a similar fashion to the * PropertyConfigurator) or they can point to separate XML or * property files. For example:
* *1. XML file delegates to {@link JAXPConfigurator} passing * in the filename. If the filename is not absolute then it is prepended * with the application directory.
* ** <servlet> * <servlet-name>ServletConfigurator</servlet-name> * <servlet-class>org.logicalcobwebs.proxool.configuration.ServletConfigurator</servlet-class> * <init-param> * <param-name>xmlFile</param-name> * <param-value>WEB-INF/proxool.xml</param-value> * </init-param> * </servlet> ** * 2. Property file delegates to {@link PropertyConfigurator} * passing in the filename. If the filename is not absolute then it is prepended * with the application directory. * *
* <servlet> * <servlet-name>ServletConfigurator</servlet-name> * <servlet-class>org.logicalcobwebs.proxool.configuration.ServletConfigurator</servlet-class> * <init-param> * <param-name>propertyFile</param-name> * <param-value>WEB-INF/proxool.properties</param-value> * </init-param> * </servlet> ** * 3. Init parameters delegates to {@link PropertyConfigurator} * by passing in a new Properties object based on the servlet's init * parameters. * *
* <servlet> * <servlet-name>ServletConfigurator</servlet-name> * <servlet-class>org.logicalcobwebs.proxool.configuration.ServletConfigurator</servlet-class> * <init-param> * <param-name>jdbc-0.proxool.alias</param-name> * <param-value>test</param-value> * </init-param> * <init-param> * <param-name>jdbc-0.proxool.driver-url</param-name> * <param-value>jdbc:hsqldb:.</param-value> * </init-param> * <init-param> * <param-name>jdbc-0.proxool.driver-class</param-name> * <param-value>org.hsqldb.jdbcDriver</param-value> * </init-param> * </servlet> ** *
It will also automatically shutdown Proxool. See * {@link #destroy}.
* * @version $Revision: 1.7 $, $Date: 2006/01/18 14:39:58 $ * @author bill * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.7 */ public class ServletConfigurator extends HttpServlet { private static final Log LOG = LogFactory.getLog(ServletConfigurator.class); private static final String XML_FILE_PROPERTY = "xmlFile"; private static final String PROPERTY_FILE_PROPERTY = "propertyFile"; private static final String AUTO_SHUTDOWN_PROPERTY = "autoShutdown"; private boolean autoShutdown = true; public void init(ServletConfig servletConfig) throws ServletException { super.init(servletConfig); String appDir = servletConfig.getServletContext().getRealPath("/"); Properties properties = new Properties(); Enumeration names = servletConfig.getInitParameterNames(); while (names.hasMoreElements()) { String name = (String) names.nextElement(); String value = servletConfig.getInitParameter(name); if (name.equals(XML_FILE_PROPERTY)) { try { File file = new File(value); if (file.isAbsolute()) { JAXPConfigurator.configure(value, false); } else { JAXPConfigurator.configure(appDir + File.separator + value, false); } } catch (ProxoolException e) { LOG.error("Problem configuring " + value, e); } } else if (name.equals(PROPERTY_FILE_PROPERTY)) { try { File file = new File(value); if (file.isAbsolute()) { PropertyConfigurator.configure(value); } else { PropertyConfigurator.configure(appDir + File.separator + value); } } catch (ProxoolException e) { LOG.error("Problem configuring " + value, e); } } else if (name.equals(AUTO_SHUTDOWN_PROPERTY)) { autoShutdown = Boolean.valueOf(value).booleanValue(); } else if (name.startsWith(PropertyConfigurator.PREFIX)) { properties.setProperty(name, value); } } if (properties.size() > 0) { try { PropertyConfigurator.configure(properties); } catch (ProxoolException e) { LOG.error("Problem configuring using init properties", e); } } } /** * Shuts down Proxool by removing all connection pools. If you want * to disable this behaviour then use: *
* <init-param>
* <param-name>autoShutdown</param-name>
* <param-value>false</param-value>
* </init-param>
*
*/
public void destroy() {
if (autoShutdown) {
ProxoolFacade.shutdown(0);
}
}
}
/*
Revision history:
$Log: ServletConfigurator.java,v $
Revision 1.7 2006/01/18 14:39:58 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.6 2003/03/10 15:26:54 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.5 2003/03/03 11:12:00 billhorsman
fixed licence
Revision 1.4 2003/02/07 17:26:25 billhorsman
use shutdown() instead of removeAllConnectionPools()
Revision 1.3 2003/02/06 17:41:05 billhorsman
now uses imported logging
Revision 1.2 2003/02/06 15:45:26 billhorsman
trivial doc changes
Revision 1.1 2003/02/05 15:03:49 billhorsman
new configuration servlet.
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/configuration/XMLConfigurator.java 0000644 0001750 0001750 00000025734 10730503124 033251 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool.configuration;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.ProxoolConstants;
import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.ProxoolFacade;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.helpers.DefaultHandler;
import java.util.Properties;
/**
* A SAX 2 ContentHandler that can configure Proxool from an XML source.
* *This is just a ContentHandler, so you must associate it with a SAX parser for it to actually do anything. * If you have JAXP available {@link JAXPConfigurator} will do this for you.
* *Properties that you pass on to the delegate driver have to be treated specially. They * must be contained within a <driver-properties> element.
* *See the Proxool properties for documentation * on the available configuration properties.
* * Example configuration: ** <proxool> * <alias>apple</alias> * <driver-url>jdbc:hsqldb:.</driver-url> * <driver-class>org.hsqldb.jdbcDriver</driver-class> * <driver-properties> * <property name="user" value="abc" /> * <property name="password" value="def" /> * </driver-properties> * <house-keeping-sleep-time>40000</house-keeping-sleep-time> * <house-keeping-test-sql>select CURRENT_DATE</house-keeping-test-sql> * <maximum-connection-count>10</maximum-connection-count> * <minimum-connection-count>3</minimum-connection-count> * <maximum-connection-lifetime>18000000</maximum-connection-lifetime> <!-- 5 hours --> * <simultaneous-build-throttle>5</simultaneous-build-throttle> * <recently-started-threshold>40000</recently-started-threshold> * <overload-without-refusal-lifetime>50000</overload-without-refusal-lifetime> * <maximum-active-time>60000</maximum-active-time> * <verbose>true</verbose> * <trace>true</trace> * <fatal-sql-exception>ORA-1234</fatal-sql-exception> * <prototype-count>2</prototype-count> * </proxool> ** * When the parser reaches the end of the <proxool> element the pool * is automatically registered. You can contain the <proxool> element * in any other elements as you wish. And the <proxool> element can * occur as many times as you wish. This allows you to use an XML file that * configures your whole application as the source. This configurator will * ignore everything apart from the elements contained within the <proxool> * element. *
* Validation
* A couple of additional steps are required if you want your SAX parser to validate your Proxool xml confguration:
*
*
* proxool-config element.
* The document must adhere to the Proxool dtd.
* DOCTYPE entry to your xml with a system id containing the absolute url to the Proxool
* dtd. The Proxool jar contains a copy of the Proxool dtd in the confguration package. You can reference that with
* a jar url like this:
* true as
* the second arghument to any of the configure methods.
*
This class is not thread safe.
* * @version $Revision: 1.18 $, $Date: 2006/01/18 14:39:58 $ * @author billhorsman * @author $Author: billhorsman $ (current maintainer) */ public class XMLConfigurator extends DefaultHandler { private static final Log LOG = LogFactory.getLog(XMLConfigurator.class); private StringBuffer content = new StringBuffer(); private String poolName; private String driverClass; private String driverUrl; private Properties properties = new Properties(); private static final String PROXOOL = "proxool"; private static final String DRIVER_PROPERTIES = "driver-properties"; private static final String PROPERTY = "property"; private static final String NAME = "name"; private static final String VALUE = "value"; private boolean insideDelegateProperties; private boolean insideProxool; /** * @see org.xml.sax.ContentHandler#startElement */ public void startElement(String uri, String lname, String qname, Attributes attributes) throws SAXException { content.setLength(0); if (!namespaceOk(uri)) { return; } final String elementName = getElementName(uri, lname, qname); if (elementName.equals(PROXOOL)) { if (insideProxool) { throw new SAXException("A <" + PROXOOL + "> element can't contain another <" + PROXOOL + "> element."); } insideProxool = true; properties.clear(); driverClass = null; driverUrl = null; } if (insideProxool) { if (elementName.equals(DRIVER_PROPERTIES)) { insideDelegateProperties = true; } else if (insideDelegateProperties) { if (elementName.equals(PROPERTY)) { setDriverProperty(attributes); } } } } /** * @see org.xml.sax.ContentHandler#characters */ public void characters(char[] chars, int start, int length) throws SAXException { if (insideProxool) { content.append(chars, start, length); } } /** * @see org.xml.sax.ContentHandler#endElement */ public void endElement(String uri, String lname, String qname) throws SAXException { if (!namespaceOk(uri)) { return; } final String elementName = getElementName(uri, lname, qname); // Are we ending a proxool configuration section? if (elementName.equals(PROXOOL)) { // Check that we have defined the minimum information if (driverClass == null || driverUrl == null) { throw new SAXException("You must define the " + ProxoolConstants.DRIVER_CLASS + " and the " + ProxoolConstants.DRIVER_URL + "."); } // Build the URL; optinally defining a name StringBuffer url = new StringBuffer(); url.append("proxool"); if (poolName != null) { url.append(ProxoolConstants.ALIAS_DELIMITER); url.append(poolName); } url.append(ProxoolConstants.URL_DELIMITER); url.append(driverClass); url.append(ProxoolConstants.URL_DELIMITER); url.append(driverUrl); if (LOG.isDebugEnabled()) { LOG.debug("Created url: " + url); } // Register the pool try { ProxoolFacade.registerConnectionPool(url.toString(), properties); } catch (ProxoolException e) { throw new SAXException(e); } // This ensures we ignore remaining XML until we come across another //
* The registered listeners are offered to subclasses through the protected {@link #getListeners} method. This
* method returns a reference to an array containing the registered listeners. A new array holding the listeners
* is created everytime a modification on the registration list is required (add/remove listener). Therefore,
* subclasses can safely iterate over the received array.
*
* Your code sould look like this:
*
*
*
Object[] listeners = getListeners();
for(int i=0; i
A customized implementation of java.util.ArrayList designed
* to operate in a multithreaded environment where the large majority of
* method calls are read-only, instead of structural changes. When operating
* in "fast" mode, read calls are non-synchronized and write calls perform the
* following steps:
When first created, objects of this class default to "slow" mode, where
* all accesses of any type are synchronized but no cloning takes place. This
* is appropriate for initially populating the collection, followed by a switch
* to "fast" mode (by calling setFast(true)) after initialization
* is complete.
NOTE: If you are creating and accessing an
* ArrayList only within a single thread, you should use
* java.util.ArrayList directly (with no synchronization), for
* maximum performance.
NOTE: This class is not cross-platform. * Using it may cause unexpected failures on some architectures. * It suffers from the same problems as the double-checked locking idiom. * In particular, the instruction that clones the internal collection and the * instruction that sets the internal reference to the clone can be executed * or perceived out-of-order. This means that any read operation might fail * unexpectedly, as it may be reading the state of the internal collection * before the internal collection is fully formed. * For more information on the double-checked locking idiom, see the * * Double-Checked Locking Idiom Is Broken Declartion.
* * @since Proxool 0.6 * @author Craig R. McClanahan * @author $Author: billhorsman $ (current maintainer) * @version $Revision: 1.4 $ $Date: 2003/03/10 23:43:18 $ */ public class FastArrayList extends ArrayList { // ----------------------------------------------------------- Constructors /** * Construct a an empty list. */ public FastArrayList() { super(); this.list = new ArrayList(); } /** * Construct an empty list with the specified capacity. * * @param capacity The initial capacity of the empty list */ public FastArrayList(int capacity) { super(); this.list = new ArrayList(capacity); } /** * Construct a list containing the elements of the specified collection, * in the order they are returned by the collection's iterator. * * @param collection The collection whose elements initialize the contents * of this list */ public FastArrayList(Collection collection) { super(); this.list = new ArrayList(collection); } // ----------------------------------------------------- Instance Variables /** * The underlying list we are managing. */ private ArrayList list = null; // ------------------------------------------------------------- Properties /** * Are we operating in "fast" mode? */ private boolean fast = false; /** * Returns true if this list is operating in fast mode. * * @return true if this list is operating in fast mode */ public boolean getFast() { return (this.fast); } /** * Sets whether this list will operate in fast mode. * * @param fast true if the list should operate in fast mode */ public void setFast(boolean fast) { this.fast = fast; } // --------------------------------------------------------- Public Methods /** * Appends the specified element to the end of this list. * * @param element The element to be appended */ public boolean add(Object element) { if (fast) { synchronized (this) { ArrayList temp = (ArrayList) list.clone(); boolean result = temp.add(element); list = temp; return (result); } } else { synchronized (list) { return (list.add(element)); } } } /** * Insert the specified element at the specified position in this list, * and shift all remaining elements up one position. * * @param index Index at which to insert this element * @param element The element to be inserted * * @exception java.lang.IndexOutOfBoundsException if the index is out of range */ public void add(int index, Object element) { if (fast) { synchronized (this) { ArrayList temp = (ArrayList) list.clone(); temp.add(index, element); list = temp; } } else { synchronized (list) { list.add(index, element); } } } /** * Append all of the elements in the specified Collection to the end * of this list, in the order that they are returned by the specified * Collection's Iterator. * * @param collection The collection to be appended */ public boolean addAll(Collection collection) { if (fast) { synchronized (this) { ArrayList temp = (ArrayList) list.clone(); boolean result = temp.addAll(collection); list = temp; return (result); } } else { synchronized (list) { return (list.addAll(collection)); } } } /** * Insert all of the elements in the specified Collection at the specified * position in this list, and shift any previous elements upwards as * needed. * * @param index Index at which insertion takes place * @param collection The collection to be added * * @exception java.lang.IndexOutOfBoundsException if the index is out of range */ public boolean addAll(int index, Collection collection) { if (fast) { synchronized (this) { ArrayList temp = (ArrayList) list.clone(); boolean result = temp.addAll(index, collection); list = temp; return (result); } } else { synchronized (list) { return (list.addAll(index, collection)); } } } /** * Remove all of the elements from this list. The list will be empty * after this call returns. * * @exception java.lang.UnsupportedOperationException ifclear()
* is not supported by this list
*/
public void clear() {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
temp.clear();
list = temp;
}
} else {
synchronized (list) {
list.clear();
}
}
}
/**
* Return a shallow copy of this FastArrayList instance.
* The elements themselves are not copied.
*/
public Object clone() {
FastArrayList results = null;
if (fast) {
results = new FastArrayList(list);
} else {
synchronized (list) {
results = new FastArrayList(list);
}
}
results.setFast(getFast());
return (results);
}
/**
* Return true if this list contains the specified element.
*
* @param element The element to test for
*/
public boolean contains(Object element) {
if (fast) {
return (list.contains(element));
} else {
synchronized (list) {
return (list.contains(element));
}
}
}
/**
* Return true if this list contains all of the elements
* in the specified Collection.
*
* @param collection Collection whose elements are to be checked
*/
public boolean containsAll(Collection collection) {
if (fast) {
return (list.containsAll(collection));
} else {
synchronized (list) {
return (list.containsAll(collection));
}
}
}
/**
* Increase the capacity of this ArrayList instance, if
* necessary, to ensure that it can hold at least the number of elements
* specified by the minimum capacity argument.
*
* @param capacity The new minimum capacity
*/
public void ensureCapacity(int capacity) {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
temp.ensureCapacity(capacity);
list = temp;
}
} else {
synchronized (list) {
list.ensureCapacity(capacity);
}
}
}
/**
* Compare the specified object with this list for equality. This
* implementation uses exactly the code that is used to define the
* list equals function in the documentation for the
* List.equals method.
*
* @param o Object to be compared to this list
*/
public boolean equals(Object o) {
// Simple tests that require no synchronization
if (o == this) {
return (true);
} else if (!(o instanceof List)) {
return (false);
}
List lo = (List) o;
// Compare the sets of elements for equality
if (fast) {
ListIterator li1 = list.listIterator();
ListIterator li2 = lo.listIterator();
while (li1.hasNext() && li2.hasNext()) {
Object o1 = li1.next();
Object o2 = li2.next();
if (!(o1 == null ? o2 == null : o1.equals(o2))) {
return (false);
}
}
return (!(li1.hasNext() || li2.hasNext()));
} else {
synchronized (list) {
ListIterator li1 = list.listIterator();
ListIterator li2 = lo.listIterator();
while (li1.hasNext() && li2.hasNext()) {
Object o1 = li1.next();
Object o2 = li2.next();
if (!(o1 == null ? o2 == null : o1.equals(o2))) {
return (false);
}
}
return (!(li1.hasNext() || li2.hasNext()));
}
}
}
/**
* Return the element at the specified position in the list.
*
* @param index The index of the element to return
*
* @exception java.lang.IndexOutOfBoundsException if the index is out of range
*/
public Object get(int index) {
if (fast) {
return (list.get(index));
} else {
synchronized (list) {
return (list.get(index));
}
}
}
/**
* Return the hash code value for this list. This implementation uses
* exactly the code that is used to define the list hash function in the
* documentation for the List.hashCode method.
*/
public int hashCode() {
if (fast) {
int hashCode = 1;
java.util.Iterator i = list.iterator();
while (i.hasNext()) {
Object o = i.next();
hashCode = 31 * hashCode + (o == null ? 0 : o.hashCode());
}
return (hashCode);
} else {
synchronized (list) {
int hashCode = 1;
java.util.Iterator i = list.iterator();
while (i.hasNext()) {
Object o = i.next();
hashCode = 31 * hashCode + (o == null ? 0 : o.hashCode());
}
return (hashCode);
}
}
}
/**
* Search for the first occurrence of the given argument, testing
* for equality using the equals() method, and return
* the corresponding index, or -1 if the object is not found.
*
* @param element The element to search for
*/
public int indexOf(Object element) {
if (fast) {
return (list.indexOf(element));
} else {
synchronized (list) {
return (list.indexOf(element));
}
}
}
/**
* Test if this list has no elements.
*/
public boolean isEmpty() {
if (fast) {
return (list.isEmpty());
} else {
synchronized (list) {
return (list.isEmpty());
}
}
}
/**
* Return an iterator over the elements in this list in proper sequence.
* equals() method, and return
* the corresponding index, or -1 if the object is not found.
*
* @param element The element to search for
*/
public int lastIndexOf(Object element) {
if (fast) {
return (list.lastIndexOf(element));
} else {
synchronized (list) {
return (list.lastIndexOf(element));
}
}
}
/**
* Return an iterator of the elements of this list, in proper sequence.
* See the implementation note on iterator().
*/
public ListIterator listIterator() {
if (fast) {
return new ListIter(0);
} else {
return list.listIterator();
}
}
/**
* Return an iterator of the elements of this list, in proper sequence,
* starting at the specified position.
* See the implementation note on iterator().
*
* @param index The starting position of the iterator to return
*
* @exception java.lang.IndexOutOfBoundsException if the index is out of range
*/
public ListIterator listIterator(int index) {
if (fast) {
return new ListIter(index);
} else {
return list.listIterator(index);
}
}
/**
* Remove the element at the specified position in the list, and shift
* any subsequent elements down one position.
*
* @param index Index of the element to be removed
*
* @exception java.lang.IndexOutOfBoundsException if the index is out of range
*/
public Object remove(int index) {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
Object result = temp.remove(index);
list = temp;
return (result);
}
} else {
synchronized (list) {
return (list.remove(index));
}
}
}
/**
* Remove the first occurrence of the specified element from the list,
* and shift any subsequent elements down one position.
*
* @param element Element to be removed
*/
public boolean remove(Object element) {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
boolean result = temp.remove(element);
list = temp;
return (result);
}
} else {
synchronized (list) {
return (list.remove(element));
}
}
}
/**
* Remove from this collection all of its elements that are contained
* in the specified collection.
*
* @param collection Collection containing elements to be removed
*
* @exception java.lang.UnsupportedOperationException if this optional operation
* is not supported by this list
*/
public boolean removeAll(Collection collection) {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
boolean result = temp.removeAll(collection);
list = temp;
return (result);
}
} else {
synchronized (list) {
return (list.removeAll(collection));
}
}
}
/**
* Remove from this collection all of its elements except those that are
* contained in the specified collection.
*
* @param collection Collection containing elements to be retained
*
* @exception java.lang.UnsupportedOperationException if this optional operation
* is not supported by this list
*/
public boolean retainAll(Collection collection) {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
boolean result = temp.retainAll(collection);
list = temp;
return (result);
}
} else {
synchronized (list) {
return (list.retainAll(collection));
}
}
}
/**
* Replace the element at the specified position in this list with
* the specified element. Returns the previous object at that position.
* array
* is not a supertype of the runtime type of every element in this list
*/
public Object[] toArray(Object array[]) {
if (fast) {
return (list.toArray(array));
} else {
synchronized (list) {
return (list.toArray(array));
}
}
}
/**
* Return a String representation of this object.
*/
public String toString() {
StringBuffer sb = new StringBuffer("FastArrayList[");
sb.append(list.toString());
sb.append("]");
return (sb.toString());
}
/**
* Trim the capacity of this ArrayList instance to be the
* list's current size. An application can use this operation to minimize
* the storage of an ArrayList instance.
*/
public void trimToSize() {
if (fast) {
synchronized (this) {
ArrayList temp = (ArrayList) list.clone();
temp.trimToSize();
list = temp;
}
} else {
synchronized (list) {
list.trimToSize();
}
}
}
private class SubList implements List {
private int first;
private int last;
private List expected;
public SubList(int first, int last) {
this.first = first;
this.last = last;
this.expected = list;
}
private List get(List l) {
if (list != expected) {
throw new ConcurrentModificationException();
}
return l.subList(first, last);
}
public void clear() {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
get(temp).clear();
last = first;
list = temp;
expected = temp;
}
} else {
synchronized (list) {
get(expected).clear();
}
}
}
public boolean remove(Object o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
boolean r = get(temp).remove(o);
if (r) {
last--;
}
list = temp;
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).remove(o);
}
}
}
public boolean removeAll(Collection o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
List sub = get(temp);
boolean r = sub.removeAll(o);
if (r) {
last = first + sub.size();
}
list = temp;
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).removeAll(o);
}
}
}
public boolean retainAll(Collection o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
List sub = get(temp);
boolean r = sub.retainAll(o);
if (r) {
last = first + sub.size();
}
list = temp;
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).retainAll(o);
}
}
}
public int size() {
if (fast) {
return get(expected).size();
} else {
synchronized (list) {
return get(expected).size();
}
}
}
public boolean isEmpty() {
if (fast) {
return get(expected).isEmpty();
} else {
synchronized (list) {
return get(expected).isEmpty();
}
}
}
public boolean contains(Object o) {
if (fast) {
return get(expected).contains(o);
} else {
synchronized (list) {
return get(expected).contains(o);
}
}
}
public boolean containsAll(Collection o) {
if (fast) {
return get(expected).containsAll(o);
} else {
synchronized (list) {
return get(expected).containsAll(o);
}
}
}
public Object[] toArray(Object[] o) {
if (fast) {
return get(expected).toArray(o);
} else {
synchronized (list) {
return get(expected).toArray(o);
}
}
}
public Object[] toArray() {
if (fast) {
return get(expected).toArray();
} else {
synchronized (list) {
return get(expected).toArray();
}
}
}
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (fast) {
return get(expected).equals(o);
} else {
synchronized (list) {
return get(expected).equals(o);
}
}
}
public int hashCode() {
if (fast) {
return get(expected).hashCode();
} else {
synchronized (list) {
return get(expected).hashCode();
}
}
}
public boolean add(Object o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
boolean r = get(temp).add(o);
if (r) {
last++;
}
list = temp;
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).add(o);
}
}
}
public boolean addAll(Collection o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
boolean r = get(temp).addAll(o);
if (r) {
last += o.size();
}
list = temp;
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).addAll(o);
}
}
}
public void add(int i, Object o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
get(temp).add(i, o);
last++;
list = temp;
expected = temp;
}
} else {
synchronized (list) {
get(expected).add(i, o);
}
}
}
public boolean addAll(int i, Collection o) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
boolean r = get(temp).addAll(i, o);
list = temp;
if (r) {
last += o.size();
}
expected = temp;
return r;
}
} else {
synchronized (list) {
return get(expected).addAll(i, o);
}
}
}
public Object remove(int i) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
Object o = get(temp).remove(i);
last--;
list = temp;
expected = temp;
return o;
}
} else {
synchronized (list) {
return get(expected).remove(i);
}
}
}
public Object set(int i, Object a) {
if (fast) {
synchronized (FastArrayList.this) {
ArrayList temp = (ArrayList) list.clone();
Object o = get(temp).set(i, a);
list = temp;
expected = temp;
return o;
}
} else {
synchronized (list) {
return get(expected).set(i, a);
}
}
}
public Iterator iterator() {
return new SubListIter(0);
}
public ListIterator listIterator() {
return new SubListIter(0);
}
public ListIterator listIterator(int i) {
return new SubListIter(i);
}
public Object get(int i) {
if (fast) {
return get(expected).get(i);
} else {
synchronized (list) {
return get(expected).get(i);
}
}
}
public int indexOf(Object o) {
if (fast) {
return get(expected).indexOf(o);
} else {
synchronized (list) {
return get(expected).indexOf(o);
}
}
}
public int lastIndexOf(Object o) {
if (fast) {
return get(expected).lastIndexOf(o);
} else {
synchronized (list) {
return get(expected).lastIndexOf(o);
}
}
}
public List subList(int f, int l) {
if (list != expected) {
throw new ConcurrentModificationException();
}
return new SubList(first + f, f + l);
}
private class SubListIter implements ListIterator {
private List expected;
private ListIterator iter;
private int lastReturnedIndex = -1;
public SubListIter(int i) {
this.expected = list;
this.iter = SubList.this.get(expected).listIterator(i);
}
private void checkMod() {
if (list != expected) {
throw new ConcurrentModificationException();
}
}
List get() {
return SubList.this.get(expected);
}
public boolean hasNext() {
checkMod();
return iter.hasNext();
}
public Object next() {
checkMod();
lastReturnedIndex = iter.nextIndex();
return iter.next();
}
public boolean hasPrevious() {
checkMod();
return iter.hasPrevious();
}
public Object previous() {
checkMod();
lastReturnedIndex = iter.previousIndex();
return iter.previous();
}
public int previousIndex() {
checkMod();
return iter.previousIndex();
}
public int nextIndex() {
checkMod();
return iter.nextIndex();
}
public void remove() {
checkMod();
if (lastReturnedIndex < 0) {
throw new IllegalStateException();
}
get().remove(lastReturnedIndex);
last--;
expected = list;
iter = get().listIterator(previousIndex());
lastReturnedIndex = -1;
}
public void set(Object o) {
checkMod();
if (lastReturnedIndex < 0) {
throw new IllegalStateException();
}
get().set(lastReturnedIndex, o);
expected = list;
iter = get().listIterator(previousIndex() + 1);
}
public void add(Object o) {
checkMod();
int i = nextIndex();
get().add(i, o);
last++;
iter = get().listIterator(i + 1);
lastReturnedIndex = 1;
}
}
}
private class ListIter implements ListIterator {
private List expected;
private ListIterator iter;
private int lastReturnedIndex = -1;
public ListIter(int i) {
this.expected = list;
this.iter = get().listIterator(i);
}
private void checkMod() {
if (list != expected) {
throw new ConcurrentModificationException();
}
}
List get() {
return expected;
}
public boolean hasNext() {
checkMod();
return iter.hasNext();
}
public Object next() {
checkMod();
lastReturnedIndex = iter.nextIndex();
return iter.next();
}
public boolean hasPrevious() {
checkMod();
return iter.hasPrevious();
}
public Object previous() {
checkMod();
lastReturnedIndex = iter.previousIndex();
return iter.previous();
}
public int previousIndex() {
checkMod();
return iter.previousIndex();
}
public int nextIndex() {
checkMod();
return iter.nextIndex();
}
public void remove() {
checkMod();
if (lastReturnedIndex < 0) {
throw new IllegalStateException();
}
get().remove(lastReturnedIndex);
expected = list;
iter = get().listIterator(previousIndex());
lastReturnedIndex = -1;
}
public void set(Object o) {
checkMod();
if (lastReturnedIndex < 0) {
throw new IllegalStateException();
}
get().set(lastReturnedIndex, o);
expected = list;
iter = get().listIterator(previousIndex() + 1);
}
public void add(Object o) {
checkMod();
int i = nextIndex();
get().add(i, o);
iter = get().listIterator(i + 1);
lastReturnedIndex = 1;
}
}
}
/*
Revision history:
$Log: FastArrayList.java,v $
Revision 1.4 2003/03/10 23:43:18 billhorsman
reapplied checkstyle that i'd inadvertently let
IntelliJ change...
Revision 1.3 2003/03/10 15:27:00 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.2 2003/03/03 11:12:02 billhorsman
fixed licence
Revision 1.1 2003/02/07 01:40:34 chr32
Ok. Now *really* moving in from main proxool package.
Revision 1.4 2003/02/07 01:34:17 chr32
Made class public.
Revision 1.3 2003/02/07 01:33:31 chr32
Moved in from main proxool package.
Revision 1.2 2003/01/15 14:51:14 billhorsman
checkstyle
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/util/ListenerContainerIF.java 0000644 0001750 0001750 00000002432 10730503124 032171 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool.util;
/**
* A container for event listeners. Implementations should cater to only one type of listeners.
* @version $Revision: 1.2 $, $Date: 2003/03/03 11:12:02 $
* @author Christian Nedregaard (christian_nedregaard@email.com)
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.7
*/
public interface ListenerContainerIF {
/**
* Add a listener to this container.
* @param listener the listener to add.
*/
void addListener(Object listener);
/**
* Remove a listener from this container.
* @param listener the listener to be removed.
* @return wether the listnener was found and removed or not.
*/
boolean removeListener(Object listener);
/**
* Get wether this container is empty or not.
* @return wether this container is empty or not.
*/
boolean isEmpty() ;
}
/*
Revision history:
$Log: ListenerContainerIF.java,v $
Revision 1.2 2003/03/03 11:12:02 billhorsman
fixed licence
Revision 1.1 2003/02/07 01:46:31 chr32
Initial revition.
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/AbstractProxyStatement.java 0000644 0001750 0001750 00000030272 10730503125 032043 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Connection;
import java.util.*;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
/**
* Contains most of the functionality that we require to manipilate the
* statement. The subclass of this defines how we delegate to the
* real statement.
* @version $Revision: 1.23 $, $Date: 2007/01/25 23:38:24 $
* @author bill
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.7
*/
abstract class AbstractProxyStatement {
private static final Log LOG = LogFactory.getLog(ProxyStatement.class);
private static final DateFormat DATE_FORMAT = new SimpleDateFormat("dd-MMM-yyyy.HH:mm:ss");
private Statement statement;
private ConnectionPool connectionPool;
private ProxyConnectionIF proxyConnection;
private Map parameters;
private String sqlStatement;
private StringBuffer sqlLog = new StringBuffer();
/**
* @param statement the real statement that we will delegate to
* @param connectionPool the connection pool that we are using
* @param proxyConnection the connection that was used to create the statement
* @param sqlStatement the SQL statement that was used to create this statement
* (optional, can be null) so that we can use if for tracing.
*/
public AbstractProxyStatement(Statement statement, ConnectionPool connectionPool, ProxyConnectionIF proxyConnection, String sqlStatement) {
this.statement = statement;
this.connectionPool = connectionPool;
this.proxyConnection = proxyConnection;
this.sqlStatement = sqlStatement;
}
/**
* Check to see whether an exception is a fatal one. If it is, then throw the connection
* away (and it won't be made available again)
* @param t the exception to test
*/
protected boolean testException(Throwable t) {
if (FatalSqlExceptionHelper.testException(connectionPool.getDefinition(), t)) {
// This SQL exception indicates a fatal problem with this connection. We should probably
// just junk it.
try {
statement.close();
connectionPool.throwConnection(proxyConnection, ConnectionListenerIF.FATAL_SQL_EXCEPTION_DETECTED, "Fatal SQL Exception has been detected");
// We should check all the existing connections as soon as possible
HouseKeeperController.sweepNow(connectionPool.getDefinition().getAlias());
LOG.warn("Connection has been thrown away because fatal exception was detected", t);
} catch (SQLException e2) {
LOG.error("Problem trying to throw away suspect connection", e2);
}
return true;
} else {
return false;
}
}
/**
* Gets the real Statement that we got from the delegate driver
* @return delegate statement
*/
public Statement getDelegateStatement() {
return statement;
}
/**
* The connection pool we are using
* @return connectionPool
*/
protected ConnectionPool getConnectionPool() {
return connectionPool;
}
/**
* The real, delegate statement
* @return statement
*/
protected Statement getStatement() {
return statement;
}
/**
* Close the statement and tell the ProxyConnection that it did so.
* @throws SQLException if it couldn't be closed
* @see ProxyConnectionIF#registerClosedStatement
*/
public void close() throws SQLException {
statement.close();
proxyConnection.registerClosedStatement(statement);
}
protected Connection getConnection() {
return ProxyFactory.getWrappedConnection((ProxyConnection) proxyConnection);
}
/**
* Whether the delegate statements are the same
* @see Object#equals
*/
public boolean equals(Object obj) {
return (statement.hashCode() == obj.hashCode());
}
/**
* Add a parameter so that we can show its value when tracing
* @param index within the procedure
* @param value an object describing its value
*/
protected void putParameter(int index, Object value) {
// Lazily instantiate parameters if necessary
if (parameters == null) {
parameters = new TreeMap(new Comparator() {
public int compare(Object o1, Object o2) {
int c = 0;
if (o1 instanceof Integer && o2 instanceof Integer) {
c = ((Integer) o1).compareTo(((Integer) o2));
}
return c;
}
});
}
Object key = new Integer(index);
if (value == null) {
parameters.put(key, "NULL");
} else if (value instanceof String) {
parameters.put(key, "'" + value + "'");
} else if (value instanceof Number) {
parameters.put(key, value);
} else if (value instanceof Boolean) {
parameters.put(key, ((Boolean) value).toString());
} else if (value instanceof Date) {
parameters.put(key, "'" + getDateAsString((Date) value) + "'");
} else {
String className = value.getClass().getName();
StringTokenizer st = new StringTokenizer(className, ".");
while (st.hasMoreTokens()) {
className = st.nextToken();
}
parameters.put(key, className);
}
}
/**
* Trace the call that was just made
* @param startTime so we can log how long it took
* @param exception if anything went wrong during execution
* @throws SQLException if the {@link ConnectionPool#onExecute onExecute} method threw one.
*/
protected void trace(long startTime, Exception exception) throws SQLException {
if (isTrace()) {
// Log if configured to
if (connectionPool.getLog().isDebugEnabled() && connectionPool.getDefinition().isTrace()) {
connectionPool.getLog().debug(sqlLog.toString() + " (" + (System.currentTimeMillis() - startTime) + " milliseconds"
+ (exception != null ? ", threw a " + exception.getClass().getName() + ": " + exception.getMessage() + ")" : ")"));
}
// Send to any listener
connectionPool.onExecute(sqlLog.toString(), (System.currentTimeMillis() - startTime), exception);
}
// Clear parameters for next time
if (parameters != null) {
parameters.clear();
}
sqlStatement = null;
sqlLog.setLength(0);
}
protected void startExecute() {
if (isTrace()) {
((ProxyConnection) proxyConnection).addSqlCall(sqlLog.toString());
}
}
/**
* Get the parameters that have been built up and use them to fill in any parameters
* withing the sqlStatement and produce a log. If the log already exists (for instance,
* if a batch is being peformed) then it is appended to the end.
*/
protected void appendToSqlLog() {
if (sqlStatement != null && sqlStatement.length() > 0 && isTrace()) {
int parameterIndex = 0;
StringTokenizer st = new StringTokenizer(sqlStatement, "?");
while (st.hasMoreTokens()) {
if (parameterIndex > 0) {
if (parameters != null) {
final Object value = parameters.get(new Integer(parameterIndex));
if (value != null) {
sqlLog.append(value);
} else {
sqlLog.append("?");
}
} else {
sqlLog.append("?");
}
}
parameterIndex++;
sqlLog.append(st.nextToken());
}
if (sqlStatement.endsWith("?")) {
if (parameterIndex > 0) {
if (parameters != null) {
final Object value = parameters.get(new Integer(parameterIndex));
if (value != null) {
sqlLog.append(value);
} else {
sqlLog.append("?");
}
} else {
sqlLog.append("?");
}
}
}
if (sqlStatement != null && !sqlStatement.trim().endsWith(";")) {
sqlLog.append("; ");
}
}
if (parameters != null) {
parameters.clear();
}
}
protected boolean isTrace() {
return getConnectionPool().isConnectionListenedTo() || (getConnectionPool().getDefinition().isTrace());
}
/**
* Sets sqlStatement if it isn't already set
* @param sqlStatement the statement we are sending the database
*/
protected void setSqlStatementIfNull(String sqlStatement) {
if (this.sqlStatement == null) {
this.sqlStatement = sqlStatement;
}
}
protected static String getDateAsString(Date date) {
return DATE_FORMAT.format(date);
}
}
/*
Revision history:
$Log: AbstractProxyStatement.java,v $
Revision 1.23 2007/01/25 23:38:24 billhorsman
Scrapped onAboutToDie and altered onDeath signature instead. Now includes reasonCode (see ConnectionListenerIF)
Revision 1.22 2006/03/03 09:58:26 billhorsman
Fix for statement.getConnection(). See bug 1149834.
Revision 1.21 2006/01/18 14:40:00 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.20 2005/10/07 08:25:15 billhorsman
Support new sqlCalls list and isTrace() is now true if the connection pool is being listened to or if trace is on. It no longer depends on the log level. This is because the sqlCalls are available in AdminServlet and not just the logs.
Revision 1.19 2005/09/26 10:01:31 billhorsman
Added lastSqlCall when trace is on.
Revision 1.18 2004/06/02 20:04:54 billhorsman
Fixed sql log: boolean and date now supported, and last parameter is included
Revision 1.17 2003/11/04 13:54:02 billhorsman
checkstyle
Revision 1.16 2003/10/27 12:21:59 billhorsman
Optimisation to avoid preparing sql log if tracing is off.
Revision 1.15 2003/10/27 11:18:42 billhorsman
Fix for sqlStatement being null.
Revision 1.14 2003/10/19 09:50:08 billhorsman
Debug exception displays class name.
Revision 1.13 2003/10/18 20:44:48 billhorsman
Better SQL logging (embed parameter values within SQL call) and works properly with batched statements now.
Revision 1.12 2003/09/30 18:39:07 billhorsman
New test-before-use, test-after-use and fatal-sql-exception-wrapper-class properties.
Revision 1.11 2003/09/05 16:26:50 billhorsman
testException() now returns true if a fatal exception was detected.
Revision 1.10 2003/03/10 23:43:09 billhorsman
reapplied checkstyle that i'd inadvertently let
IntelliJ change...
Revision 1.9 2003/03/10 15:26:42 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.8 2003/03/05 18:42:32 billhorsman
big refactor of prototyping and house keeping to
drastically reduce the number of threads when using
many pools
Revision 1.7 2003/03/03 11:11:56 billhorsman
fixed licence
Revision 1.6 2003/02/26 16:05:52 billhorsman
widespread changes caused by refactoring the way we
update and redefine pool definitions.
Revision 1.5 2003/02/19 22:38:32 billhorsman
fatal sql exception causes house keeper to run
immediately
Revision 1.4 2003/02/13 17:06:42 billhorsman
allow for sqlStatement in execute() method
Revision 1.3 2003/02/06 17:41:04 billhorsman
now uses imported logging
Revision 1.2 2003/01/28 11:47:08 billhorsman
new isTrace() and made close() public
Revision 1.1 2003/01/27 18:26:35 billhorsman
refactoring of ProxyConnection and ProxyStatement to
make it easier to write JDK 1.2 patch
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/CompositeConfigurationListener.java 0000644 0001750 0001750 00000005756 10730503125 033562 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import java.util.Properties;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.util.AbstractListenerContainer;
/**
* A {@link ConfigurationListenerIF} that keeps a list of ConfigurationListenerIFs
* and notifies them in a thread safe manner.
* It also implements {@link org.logicalcobwebs.proxool.util.ListenerContainerIF ListenerContainerIF}
* which provides methods for
* {@link org.logicalcobwebs.proxool.util.ListenerContainerIF#addListener(Object) adding} and
* {@link org.logicalcobwebs.proxool.util.ListenerContainerIF#removeListener(Object) removing} listeners.
*
* @version $Revision: 1.7 $, $Date: 2006/01/18 14:40:01 $
* @author Christian Nedregaard (christian_nedregaard@email.com)
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.7
*/
public class CompositeConfigurationListener extends AbstractListenerContainer implements ConfigurationListenerIF {
static final Log LOG = LogFactory.getLog(CompositeConfigurationListener.class);
/**
* @see ConfigurationListenerIF#definitionUpdated(ConnectionPoolDefinitionIF, Properties, Properties)
*/
public void definitionUpdated( ConnectionPoolDefinitionIF connectionPoolDefinition,
Properties completeInfo,
Properties changedInfo)
{
Object[] listeners = getListeners();
for(int i=0; i
* String alias = "myPool";
* Iterator i = ProxoolFacade.getConnectionInfos(alias).iterator();
* while (i.hasNext()) {
* ConnectionInfoIF c = (ConnectionInfoIF)i.next();
* ...
* }
*
*
* @version $Revision: 1.12 $, $Date: 2005/10/07 08:18:23 $
* @author billhorsman
* @author $Author: billhorsman $ (current maintainer)
*/
public interface ConnectionInfoIF extends Comparable {
/**
* Default - treat as normal
* @see #getMark
*/
static final int MARK_FOR_USE = 0;
/**
* The next time this connection is made available we should expire it.
* @see #getMark
*/
static final int MARK_FOR_EXPIRY = 1;
/**
* This is the start and end state of every connection
* @see #getStatus
*/
static final int STATUS_NULL = 0;
/**
* The connection is available for use
* @see #getStatus
*/
static final int STATUS_AVAILABLE = 1;
/**
* The connection is in use
* @see #getStatus
*/
static final int STATUS_ACTIVE = 2;
/**
* The connection is in use by the house keeping thread
* @see #getStatus
*/
static final int STATUS_OFFLINE = 3;
/**
* The time that this connection was created.
* The number of milliseconds
* since midnight, January 1, 1970 UTC.
*/
long getBirthTime();
/**
* Like {@link #getBirthTime} but in Date format
* @return birthDate
*/
Date getBirthDate();
/**
* The age in millseconds since this connection was built
*/
long getAge();
/**
* A unique ID for this connection
*/
long getId();
/**
* Sometimes we want do something to a connection but can't because it is still
* active and we don't want to disrupt its use. So we mark it instead and when it
* stops being active we can perform the necessary operation.
*
* The only thing we do at the moment is {@link #MARK_FOR_EXPIRY expire} the
* connection (if it is too old for instance). And this will happen if the
* housekeeper decides it should but the connection is still active.
*/
int getMark();
/**
* The status of the connection. Can be either:
* {@link #STATUS_NULL null},
* {@link #STATUS_AVAILABLE available},
* {@link #STATUS_ACTIVE active} or
* {@link #STATUS_OFFLINE offline}.
*/
int getStatus();
/**
* When this connection was last given out. The number of milliseconds
* since midnight, January 1, 1970 UTC.
*/
long getTimeLastStartActive();
/**
* When this connection was last given back (or zero if it is still active).
* The number of milliseconds
* since midnight, January 1, 1970 UTC.
*/
long getTimeLastStopActive();
/**
* The name of the thread that asked for this connection.
*/
String getRequester();
/**
* The hashcode (in hex) of the ProxyConnection object. This
* uniquely identifies this proxy connection.
* @return proxyHashcode
*/
String getProxyHashcode();
/**
* The hashcode (in hex) of the delegate connection object. This
* uniquely identifies the underlying connection.
* @return delegateHashcode
*/
String getDelegateHashcode();
/**
* The URL that this connection is using (the definition
* might have changed since this connection was built).
* @return delegateUrl
*/
String getDelegateUrl();
/**
* A log of the last SQL used on this connection. Only populated
* if {@link org.logicalcobwebs.proxool.ConnectionPoolDefinitionIF#isTrace()}
* is enabled.
* @return the most recent SQL to be used
*/
String[] getSqlCalls();
}
/*
Revision history:
$Log: ConnectionInfoIF.java,v $
Revision 1.12 2005/10/07 08:18:23 billhorsman
New sqlCalls gives list of SQL calls rather than just he most recent (for when a connection makes more than one call before being returned to the pool)
Revision 1.11 2005/09/26 10:01:31 billhorsman
Added lastSqlCall when trace is on.
Revision 1.10 2003/10/30 00:05:50 billhorsman
now implements Comparable (using ID)
Revision 1.9 2003/03/03 11:11:57 billhorsman
fixed licence
Revision 1.8 2003/02/12 12:28:27 billhorsman
added url, proxyHashcode and delegateHashcode to
ConnectionInfoIF
Revision 1.7 2003/01/31 11:38:57 billhorsman
birthDate now stored as Date not long
Revision 1.6 2003/01/27 18:26:35 billhorsman
refactoring of ProxyConnection and ProxyStatement to
make it easier to write JDK 1.2 patch
Revision 1.5 2003/01/15 00:12:13 billhorsman
doc
Revision 1.4 2002/12/15 19:21:42 chr32
Changed @linkplain to @link (to preserve JavaDoc for 1.2/1.3 users).
Revision 1.3 2002/10/25 16:00:19 billhorsman
added better class javadoc
Revision 1.2 2002/09/18 13:48:56 billhorsman
checkstyle and doc
Revision 1.1.1.1 2002/09/13 08:12:32 billhorsman
new
Revision 1.3 2002/06/28 11:19:47 billhorsman
improved doc
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ConnectionListenerIF.java 0000644 0001750 0001750 00000014332 10730503125 031374 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import java.sql.Connection;
import java.sql.SQLException;
/**
* You can listen to the lifecycle of a connection. Sometimes, you may
* want to perform a task when the connection is born or dies. Actually,
* the reason why we originally did this is now obsolete. But the code
* remains here just in case. You need to
* {@link ProxoolFacade#setConnectionListener register}
* your implementation with ProxoolFacade.
*
*
* String alias = "myPool";
* ConnectionListenerIF myConnectionListener = new MyConnectionListener();
* ProxoolFacade.{@link org.logicalcobwebs.proxool.ProxoolFacade#addConnectionListener addConnectionListener}(alias, myConnectionListener);
*
*
* @version $Revision: 1.9 $, $Date: 2007/01/25 23:38:24 $
* @author billhorsman
* @author $Author: billhorsman $ (current maintainer)
*/
public interface ConnectionListenerIF {
/**
* We are killing a connection because the
* {@link org.logicalcobwebs.proxool.ProxoolConstants#MAXIMUM_ACTIVE_TIME MAXIMUM_ACTIVE_TIME}
* has been exceeded.
* @see #onDeath(java.sql.Connection, int)
*/
static final int MAXIMUM_ACTIVE_TIME_EXPIRED = 1;
/**
* We are killing a connection because it's manually been expired (by something external to
* Proxool)
* @see #onDeath(java.sql.Connection, int)
*/
static final int MANUAL_EXPIRY = 2;
/**
* We are killing a connection because it has not been
* {@link org.logicalcobwebs.proxool.ConnectionValidatorIF#validate(ConnectionPoolDefinitionIF, java.sql.Connection) validated}.
* @see #onDeath(java.sql.Connection, int)
*/
static final int VALIDATION_FAIL = 3;
/**
* We are killing a connection because Proxool is shutting down
* @see #onDeath(java.sql.Connection, int)
*/
static final int SHUTDOWN = 4;
/**
* We are killing a connection because it couldn't be {@link org.logicalcobwebs.proxool.ConnectionResetter#reset(java.sql.Connection, String) reset}
* after it was returned to the pool and we don't want to give it out again in an unknown state.
* @see #onDeath(java.sql.Connection, int)
*/
static final int RESET_FAIL = 5;
/**
* We are killing a connection because the routine house keeper test failed
* @see #onDeath(java.sql.Connection, int)
*/
static final int HOUSE_KEEPER_TEST_FAIL = 6;
/**
* We are killing a connection because it's {@link org.logicalcobwebs.proxool.ProxoolConstants#MAXIMUM_CONNECTION_LIFETIME MAXIMUM_CONNECTION_LIFETIME}
* has been exceeded.
* @see #onDeath(java.sql.Connection, int)
*/
static final int MAXIMUM_CONNECTION_LIFETIME_EXCEEDED = 7;
/**
* We are killing a connection because a {@link org.logicalcobwebs.proxool.ProxoolConstants#FATAL_SQL_EXCEPTION FATAL_SQL_EXCEPTION}
* has been detected.
* @see #onDeath(java.sql.Connection, int)
*/
static final int FATAL_SQL_EXCEPTION_DETECTED = 8;
/**
* Happens everytime we create a new connection. You can use this
* to allocate resources to a connection that might be useful during
* the lifetime of the connection.
*
* @param connection the connection that has just been created
* @throws SQLException if anything goes wrong (which will then be logged but ignored)
*/
void onBirth(Connection connection) throws SQLException;
/**
* Happens just before we expire a connection. You can use this to
* reclaim resources from a connection.
*
* @param connection the connection that is about to expire
* @param reasonCode {@link #MAXIMUM_ACTIVE_TIME_EXPIRED},
* {@link #HOUSE_KEEPER_TEST_FAIL},
* {@link #FATAL_SQL_EXCEPTION_DETECTED},
* {@link #MANUAL_EXPIRY},
* {@link #MAXIMUM_CONNECTION_LIFETIME_EXCEEDED},
* {@link #RESET_FAIL},
* {@link #SHUTDOWN}, or
* {@link #VALIDATION_FAIL}
* @throws SQLException if anything goes wrong (which will then be logged but ignored)
*/
void onDeath(Connection connection, int reasonCode) throws SQLException;
/**
* Happens after every successful execute. Note that the command
* is not fully implemented at this stage. At some point it might represent
* the SQL that is sent to the database (or the procedure call that was used).
*
* @param command what command was being executed
* @param elapsedTime how long the call took (in milliseconds)
*/
void onExecute(String command, long elapsedTime);
/**
* Happens everytime an exception was thrown during an execute method
* Note that the command
* is not fully implemented at this stage. At some point it might represent
* the SQL that is sent to the database (or the procedure call that was used).
*
* @param command what command was being executed
* @param exception what exception was thrown
*/
void onFail(String command, Exception exception);
}
/*
Revision history:
$Log: ConnectionListenerIF.java,v $
Revision 1.9 2007/01/25 23:38:24 billhorsman
Scrapped onAboutToDie and altered onDeath signature instead. Now includes reasonCode (see ConnectionListenerIF)
Revision 1.8 2007/01/25 00:10:24 billhorsman
New onAboutToDie event for ConnectionListenerIF that gets called if the maximum-active-time is exceeded.
Revision 1.7 2003/03/03 11:11:57 billhorsman
fixed licence
Revision 1.6 2003/02/08 00:35:30 billhorsman
doc
Revision 1.5 2002/12/15 19:21:42 chr32
Changed @linkplain to @link (to preserve JavaDoc for 1.2/1.3 users).
Revision 1.4 2002/10/25 16:00:20 billhorsman
added better class javadoc
Revision 1.3 2002/10/23 21:04:36 billhorsman
checkstyle fixes (reduced max line width and lenient naming convention
Revision 1.2 2002/10/16 11:45:52 billhorsman
removed obsolete cleanupClob method and added more javadoc
Revision 1.1.1.1 2002/09/13 08:12:34 billhorsman
new
Revision 1.5 2002/08/24 19:43:04 billhorsman
new execute events
Revision 1.4 2002/06/28 11:15:41 billhorsman
didn't really need ListenerIF
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ConnectionPool.java 0000644 0001750 0001750 00000154400 10730503125 030302 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.concurrent.ReaderPreferenceReadWriteLock;
import org.logicalcobwebs.concurrent.WriterPreferenceReadWriteLock;
import org.logicalcobwebs.proxool.admin.Admin;
import org.logicalcobwebs.proxool.util.FastArrayList;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.*;
/**
* This is where most things happen. (In fact, probably too many things happen in this one
* class).
* @version $Revision: 1.86 $, $Date: 2007/01/25 23:38:24 $
* @author billhorsman
* @author $Author: billhorsman $ (current maintainer)
*/
class ConnectionPool implements ConnectionPoolStatisticsIF {
/**
* Use this for messages that aren't useful for the pool specific log
*/
private static final Log LOG = LogFactory.getLog(ConnectionPool.class);
/**
* Here we deviate from the standard of using the classname for the log
* name. Here we want to use the alias for the pool so that we can log
* each pool to different places. So we have to instantiate the log later.
*/
private Log log;
private ReaderPreferenceReadWriteLock connectionStatusReadWriteLock = new ReaderPreferenceReadWriteLock();
/**
* If you want to shutdown the pool you should get a write lock on this. And if you use the pool then
* get a read lock. This stops us trying to shutdown the pool whilst it is in use. Only, we don't want
* to delay shutdown just because some greedy user has got a connection active. Shutdown should be
* relatively immediate. So we don't ask for a read lock for the whole time that a connection is active.
*/
private WriterPreferenceReadWriteLock primaryReadWriteLock = new WriterPreferenceReadWriteLock();
private static final String[] STATUS_DESCRIPTIONS = {"NULL", "AVAILABLE", "ACTIVE", "OFFLINE"};
private static final String MSG_MAX_CONNECTION_COUNT =
"Couldn't get connection because we are at maximum connection count and there are none available";
/** This is the pool itself */
private List proxyConnections;
/** This is the "round robin" that makes sure we use all the connections */
private int nextAvailableConnection = 0;
private long connectionsServedCount = 0;
private long connectionsRefusedCount = 0;
/** This keeps a count of how many connections there are in each state */
private int[] connectionCountByState = new int[4];
private ConnectionPoolDefinition definition;
private CompositeConnectionListener compositeConnectionListener = new CompositeConnectionListener();
private CompositeStateListener compositeStateListener = new CompositeStateListener();
private long timeOfLastRefusal = 0;
private int upState;
private static boolean loggedLegend;
private Admin admin;
private boolean locked = false;
private Date dateStarted = new Date();
private boolean connectionPoolUp = false;
/**
* This gets set during {@link #shutdown}. We use it to notify shutdown
* that all connections are now non-active.
*/
private Thread shutdownThread;
private Prototyper prototyper;
/**
* Initialised in {@link ConnectionPool#ConnectionPool constructor}.
*/
private ConnectionResetter connectionResetter;
private ConnectionValidatorIF connectionValidator;
protected ConnectionPool(ConnectionPoolDefinition definition) throws ProxoolException {
// Use the FastArrayList for performance and thread safe
// behaviour. We set its behaviour to "fast" (meaning reads are
// unsynchronized, whilst writes are not).
FastArrayList fal = new FastArrayList();
fal.setFast(true);
proxyConnections = fal;
log = LogFactory.getLog("org.logicalcobwebs.proxool." + definition.getAlias());
connectionResetter = new ConnectionResetter(log, definition.getDriver());
setDefinition(definition);
connectionValidator = new DefaultConnectionValidator();
if (definition.getStatistics() != null) {
try {
admin = new Admin(definition);
} catch (ProxoolException e) {
log.error("Failed to initialise statistics", e);
}
}
ShutdownHook.init();
}
/** Starts up house keeping and prototyper threads. */
protected void start() throws ProxoolException {
connectionPoolUp = true;
prototyper = new Prototyper(this);
HouseKeeperController.register(this);
}
/**
* Get a connection from the pool. If none are available or there was an Exception
* then an exception is thrown and something written to the log
*/
protected Connection getConnection() throws SQLException {
String requester = Thread.currentThread().getName();
/*
*If we're busy, we need to return as quickly as possible. Because this is unsynchronized
* we run the risk of refusing a connection when we might actually be able to. But that will
* only happen when we're right at or near maximum connections anyway.
*/
try {
prototyper.quickRefuse();
} catch (SQLException e) {
connectionsRefusedCount++;
if (admin != null) {
admin.connectionRefused();
}
log.info(displayStatistics() + " - " + MSG_MAX_CONNECTION_COUNT);
timeOfLastRefusal = System.currentTimeMillis();
setUpState(StateListenerIF.STATE_OVERLOADED);
throw e;
}
prototyper.checkSimultaneousBuildThrottle();
ProxyConnection proxyConnection = null;
try {
// We need to look at all the connections, but we don't want to keep looping round forever
for (int connectionsTried = 0; connectionsTried < proxyConnections.size(); connectionsTried++) {
// By doing this in a try/catch we avoid needing to synch on the size(). We need to do be
// able to cope with connections being removed whilst we are going round this loop
try {
proxyConnection = (ProxyConnection) proxyConnections.get(nextAvailableConnection);
} catch (ArrayIndexOutOfBoundsException e) {
// This is thrown by a Vector (which we no longer use), but is
// kept here for a while.
nextAvailableConnection = 0;
proxyConnection = (ProxyConnection) proxyConnections.get(nextAvailableConnection);
} catch (IndexOutOfBoundsException e) {
// This is thrown by a true List
nextAvailableConnection = 0;
proxyConnection = (ProxyConnection) proxyConnections.get(nextAvailableConnection);
}
// setActive() returns false if the ProxyConnection wasn't available. You
// can't set it active twice (at least, not without making it available again
// in between)
if (proxyConnection != null && proxyConnection.setStatus(ProxyConnectionIF.STATUS_AVAILABLE, ProxyConnectionIF.STATUS_ACTIVE)) {
// Okay. So we have it. But is it working ok?
if (getDefinition().isTestBeforeUse()) {
if (!testConnection(proxyConnection)) {
// Oops. No it's not. Let's choose another.
proxyConnection = null;
}
}
if (proxyConnection != null) {
nextAvailableConnection++;
break;
}
} else {
proxyConnection = null;
}
nextAvailableConnection++;
}
// Did we get one?
if (proxyConnection == null) {
try {
// No! Let's see if we can create one
proxyConnection = prototyper.buildConnection(ProxyConnection.STATUS_ACTIVE, "on demand");
// Okay. So we have it. But is it working ok?
if (getDefinition().isTestBeforeUse()) {
if (!testConnection(proxyConnection)) {
// Oops. No it's not. There's not much more we can do for now
throw new SQLException("Created a new connection but it failed its test");
}
}
} catch (SQLException e) {
throw e;
} catch (ProxoolException e) {
log.debug("Couldn't get connection", e);
throw new SQLException(e.toString());
} catch (Throwable e) {
log.error("Couldn't get connection", e);
throw new SQLException(e.toString());
}
}
} catch (SQLException e) {
throw e;
} catch (Throwable t) {
log.error("Problem getting connection", t);
throw new SQLException(t.toString());
} finally {
if (proxyConnection != null) {
connectionsServedCount++;
proxyConnection.setRequester(requester);
} else {
connectionsRefusedCount++;
if (admin != null) {
admin.connectionRefused();
}
timeOfLastRefusal = System.currentTimeMillis();
setUpState(StateListenerIF.STATE_OVERLOADED);
}
}
if (proxyConnection == null) {
throw new SQLException("Unknown reason for not getting connection. Sorry.");
}
if (log.isDebugEnabled() && getDefinition().isVerbose()) {
log.debug(displayStatistics() + " - Connection #" + proxyConnection.getId() + " served");
}
// This gives the proxy connection a chance to reset itself before it is served.
proxyConnection.open();
return ProxyFactory.getWrappedConnection(proxyConnection);
}
/**
* Test the connection (if required)
* If the connection fails the test, it is removed from the pool.
* If no ConnectionValidatorIF is defined, then the test always succeed.
*
* @param proxyConnection the connection to test
* @return TRUE if the connection pass the test, FALSE if it fails
*/
private boolean testConnection(ProxyConnectionIF proxyConnection) {
// is validation enabled ?
if( connectionValidator == null ) {
return true;
}
// validate the connection
boolean success = connectionValidator.validate(getDefinition(), proxyConnection.getConnection());
if( success ) {
if (LOG.isDebugEnabled()) {
LOG.debug(displayStatistics() + " - Connection #" + proxyConnection.getId() + " tested: OK");
}
}
else {
proxyConnection.setStatus(ProxyConnectionIF.STATUS_NULL);
removeProxyConnection(proxyConnection, ConnectionListenerIF.VALIDATION_FAIL, "it didn't pass the validation", ConnectionPool.REQUEST_EXPIRY, true);
}
// return
return success;
}
/**
* Add a ProxyConnection to the pool
* @param proxyConnection new connection
* @return true if the connection was added or false if it wasn't (for instance, if the definition it
* was built with is out of date).
*/
protected boolean addProxyConnection(ProxyConnectionIF proxyConnection) {
boolean added = false;
try {
acquireConnectionStatusWriteLock();
if (proxyConnection.getDefinition() == getDefinition()) {
proxyConnections.add(proxyConnection);
connectionCountByState[proxyConnection.getStatus()]++;
added = true;
}
} finally {
releaseConnectionStatusWriteLock();
}
return added;
}
protected static String getStatusDescription(int status) {
try {
return STATUS_DESCRIPTIONS[status];
} catch (ArrayIndexOutOfBoundsException e) {
return "Unknown status: " + status;
}
}
/**
* When you have finished with a Connection you should put it back here. That will make it available to others.
* Unless it's due for expiry, in which case it will... expire
*/
protected void putConnection(ProxyConnectionIF proxyConnection) {
if (admin != null) {
long now = System.currentTimeMillis();
long start = proxyConnection.getTimeLastStartActive();
if (now - start < 0) {
log.warn("Future start time detected. #" + proxyConnection.getId() + " start = " + new Date(start)
+ " (" + (now - start) + " milliseconds)");
} else if (now - start > 1000000) {
log.warn("Suspiciously long active time. #" + proxyConnection.getId() + " start = " + new Date(start));
}
admin.connectionReturned(now - start);
}
// It's possible that this connection is due for expiry
if (proxyConnection.isMarkedForExpiry()) {
if (proxyConnection.setStatus(ProxyConnectionIF.STATUS_ACTIVE, ProxyConnectionIF.STATUS_NULL)) {
expireProxyConnection(proxyConnection, proxyConnection.getReasonCode(), proxyConnection.getReasonForMark(), REQUEST_EXPIRY);
}
} else {
// Optionally, test it to see if it is ok
if (getDefinition().isTestAfterUse()) {
// It will get removed by this call if it is no good
testConnection(proxyConnection);
}
// Let's make it available for someone else
if (!proxyConnection.setStatus(ProxyConnectionIF.STATUS_ACTIVE, ProxyConnectionIF.STATUS_AVAILABLE)) {
if (proxyConnection.getStatus() == ProxyConnectionIF.STATUS_AVAILABLE) {
// This is *probably* because the connection has been closed twice.
// Although we can't tell for sure. We'll have to refactor this to use
// throw away wrappers to avoid this problem.
log.warn("Unable to close connection " + proxyConnection.getId()
+ " - I suspect that it has been closed already. Closing it more"
+ " than once is unwise and should be avoided.");
} else {
log.warn("Unable to set status of connection " + proxyConnection.getId()
+ " from " + getStatusDescription(ProxyConnectionIF.STATUS_ACTIVE)
+ " to " + getStatusDescription(ProxyConnectionIF.STATUS_AVAILABLE)
+ " because it's state was " + getStatusDescription(proxyConnection.getStatus()));
}
}
}
if (log.isDebugEnabled() && getDefinition().isVerbose()) {
log.debug(displayStatistics() + " - Connection #" + proxyConnection.getId() + " returned (now "
+ getStatusDescription(proxyConnection.getStatus()) + ")");
}
}
/** This means that there's something wrong the connection and it's probably best if no one uses it again. */
protected void throwConnection(ProxyConnectionIF proxyConnection, int reasonCode, String reason) {
expireConnectionAsSoonAsPossible(proxyConnection, reasonCode, reason, true);
}
/** Get a ProxyConnection by index */
private ProxyConnectionIF getProxyConnection(int i) {
return (ProxyConnectionIF) proxyConnections.get(i);
}
/**
* Return an array of all the connections
* @return array of connections
*/
protected ProxyConnectionIF[] getProxyConnections() {
return (ProxyConnectionIF[]) proxyConnections.toArray(new ProxyConnectionIF[proxyConnections.size()]);
}
/**
* Remove a ProxyConnection by calling its {@link ConnectionListenerIF#onDeath onDeath} event,
* closing it (for real) and then removing it from the list.
* @param proxyConnection the connection to remove
* @param reason for log audit
* @param forceExpiry true means close now, whether it is active or not; false means if it is active then
* merely mark it for expiry so that it is removed as soon as it finished being active
* @param triggerSweep if true then this removal will trigger a prototype sweep
*/
protected void removeProxyConnection(ProxyConnectionIF proxyConnection, int reasonCode, String reason, boolean forceExpiry, boolean triggerSweep) {
// Just check that it is null
if (forceExpiry || proxyConnection.isNull()) {
proxyConnection.setStatus(ProxyConnectionIF.STATUS_NULL);
/* Run some code everytime we destroy a connection */
try {
onDeath(proxyConnection.getConnection(), reasonCode);
} catch (SQLException e) {
log.error("Problem during onDeath (ignored)", e);
}
// The reallyClose() method also decrements the connectionCount.
try {
proxyConnection.reallyClose();
} catch (SQLException e) {
log.error(e);
}
try {
// If we're shutting down then getting a write lock will cause a deadlock
if (isConnectionPoolUp()) {
acquireConnectionStatusWriteLock();
}
proxyConnections.remove(proxyConnection);
} finally {
if (isConnectionPoolUp()) {
releaseConnectionStatusWriteLock();
}
}
if (log.isDebugEnabled()) {
log.debug(displayStatistics() + " - #" + FormatHelper.formatMediumNumber(proxyConnection.getId())
+ " removed because " + reason + ".");
}
if (triggerSweep) {
PrototyperController.triggerSweep(getDefinition().getAlias());
}
} else {
log.error(displayStatistics() + " - #" + FormatHelper.formatMediumNumber(proxyConnection.getId())
+ " was not removed because isNull() was false.");
}
}
protected void expireProxyConnection(ProxyConnectionIF proxyConnection, int reasonCode, String reason, boolean forceExpiry) {
removeProxyConnection(proxyConnection, reasonCode, reason, forceExpiry, true);
}
/**
* Call this to shutdown gracefully.
* @param delay how long to wait for connections to become free before forcing them to close anyway
*/
protected void shutdown(int delay, String finalizerName) throws Throwable {
final String alias = getDefinition().getAlias();
try {
/* This will stop us giving out any more connections and may
cause some of the threads to die. */
acquirePrimaryWriteLock();
if (connectionPoolUp) {
connectionPoolUp = false;
long startFinalize = System.currentTimeMillis();
shutdownThread = Thread.currentThread();
if (delay > 0) {
log.info("Shutting down '" + alias + "' pool started at "
+ dateStarted + " - waiting for " + delay
+ " milliseconds for everything to stop. [ "
+ finalizerName + "]");
} else {
log.info("Shutting down '" + alias + "' pool immediately [" + finalizerName + "]");
}
/* Interrupt the threads (in case they're sleeping) */
boolean connectionClosedManually = false;
try {
try {
HouseKeeperController.cancel(alias);
} catch (ProxoolException e) {
log.error("Shutdown couldn't cancel house keeper", e);
}
// Cancel the admin thread (for statistics)
if (admin != null) {
admin.cancelAll();
}
/* Patience, patience. */
if (connectionCountByState[ProxyConnectionIF.STATUS_ACTIVE] != 0) {
long endWait = startFinalize + delay;
LOG.info("Waiting until " + new Date(endWait) + " for all connections to become inactive (active count is "
+ connectionCountByState[ProxyConnectionIF.STATUS_ACTIVE] + ").");
while (true) {
long timeout = endWait - System.currentTimeMillis();
if (timeout > 0) {
synchronized (Thread.currentThread()) {
try {
Thread.currentThread().wait(timeout);
} catch (InterruptedException e) {
log.debug("Interrupted whilst sleeping.");
}
}
}
int activeCount = connectionCountByState[ProxyConnectionIF.STATUS_ACTIVE];
if (activeCount == 0) {
break;
}
if (System.currentTimeMillis() < endWait) {
LOG.info("Still waiting for active count to reach zero (currently " + activeCount + ").");
} else {
// There are still connections active. Oh well, we're not _that_ patient
LOG.warn("Shutdown waited for "
+ (System.currentTimeMillis() - startFinalize) + " milliseconds for all "
+ "the connections to become inactive but the active count is still "
+ activeCount + ". Shutting down anyway.");
break;
}
Thread.sleep(100);
}
}
prototyper.cancel();
// Silently close all connections
for (int i = proxyConnections.size() - 1; i >= 0; i--) {
long id = getProxyConnection(i).getId();
try {
connectionClosedManually = true;
removeProxyConnection(getProxyConnection(i), ConnectionListenerIF.SHUTDOWN, "of shutdown", true, false);
if (log.isDebugEnabled()) {
log.debug("Connection #" + id + " closed");
}
} catch (Throwable t) {
if (log.isDebugEnabled()) {
log.debug("Problem closing connection #" + id, t);
}
}
}
} catch (Throwable t) {
log.error("Unknown problem finalizing pool", t);
} finally {
ConnectionPoolManager.getInstance().removeConnectionPool(alias);
if (log.isDebugEnabled()) {
log.info("'" + alias + "' pool has been closed down by " + finalizerName
+ " in " + (System.currentTimeMillis() - startFinalize) + " milliseconds.");
if (!connectionClosedManually) {
log.debug("No connections required manual removal.");
}
}
super.finalize();
}
} else {
if (log.isDebugEnabled()) {
log.debug("Ignoring duplicate attempt to shutdown '" + alias + "' pool by " + finalizerName);
}
}
} catch (Throwable t) {
log.error(finalizerName + " couldn't shutdown pool", t);
} finally {
releasePrimaryWriteLock();
}
}
/**
* You should {@link #acquireConnectionStatusReadLock acquire}
* a read lock if you want this to be accurate (but that might have
* an impact on the performance of your pool).
* @see ConnectionPoolStatisticsIF#getAvailableConnectionCount
*/
public int getAvailableConnectionCount() {
return connectionCountByState[ConnectionInfoIF.STATUS_AVAILABLE];
}
/**
* You should {@link #acquireConnectionStatusReadLock acquire}
* a read lock if you want this to be accurate (but that might have
* an impact on the performance of your pool).
* @see ConnectionPoolStatisticsIF#getActiveConnectionCount
*/
public int getActiveConnectionCount() {
return connectionCountByState[ConnectionInfoIF.STATUS_ACTIVE];
}
/**
* You should {@link #acquireConnectionStatusReadLock acquire}
* a read lock if you want this to be accurate (but that might have
* an impact on the performance of your pool).
* @see ConnectionPoolStatisticsIF#getOfflineConnectionCount
*/
public int getOfflineConnectionCount() {
return connectionCountByState[ConnectionInfoIF.STATUS_OFFLINE];
}
protected String displayStatistics() {
if (!loggedLegend) {
log.info("Proxool statistics legend: \"s - r (a/t/o)\" > s=served, r=refused (only shown if non-zero), a=active, t=total, o=offline (being tested)");
loggedLegend = true;
}
StringBuffer statistics = new StringBuffer();
statistics.append(FormatHelper.formatBigNumber(getConnectionsServedCount()));
if (getConnectionsRefusedCount() > 0) {
statistics.append(" -");
statistics.append(FormatHelper.formatBigNumber(getConnectionsRefusedCount()));
}
statistics.append(" (");
statistics.append(FormatHelper.formatSmallNumber(getActiveConnectionCount()));
statistics.append("/");
statistics.append(FormatHelper.formatSmallNumber(getAvailableConnectionCount() + getActiveConnectionCount()));
statistics.append("/");
statistics.append(FormatHelper.formatSmallNumber(getOfflineConnectionCount()));
statistics.append(")");
// Don't need this triple check any more.
/*
if (getDefinition().getDebugLevel() == ConnectionPoolDefinitionIF.DEBUG_LEVEL_LOUD) {
statistics.append(", cc=");
statistics.append(connectionCount);
statistics.append(", ccc=");
statistics.append(connectedConnectionCount);
}
*/
return statistics.toString();
}
protected void expireAllConnections(int reasonCode, String reason, boolean merciful) {
// Do this in two stages because expiring a connection will trigger
// the prototyper to make more. And that might mean we end up
// killing a newly made connection;
Set pcs = new HashSet();
for (int i = proxyConnections.size() - 1; i >= 0; i--) {
pcs.add(proxyConnections.get(i));
}
Iterator i = pcs.iterator();
while (i.hasNext()) {
ProxyConnectionIF pc = (ProxyConnectionIF) i.next();
expireConnectionAsSoonAsPossible(pc, reasonCode, reason, merciful);
}
}
protected void expireConnectionAsSoonAsPossible(ProxyConnectionIF proxyConnection, int reasonCode, String reason, boolean merciful) {
if (proxyConnection.setStatus(ProxyConnectionIF.STATUS_AVAILABLE, ProxyConnectionIF.STATUS_OFFLINE)) {
if (proxyConnection.setStatus(ProxyConnectionIF.STATUS_OFFLINE, ProxyConnectionIF.STATUS_NULL)) {
// It is. Expire it now .
expireProxyConnection(proxyConnection, reasonCode, reason, REQUEST_EXPIRY);
}
} else {
// Oh no, it's in use.
if (merciful) {
//Never mind, we'll mark it for expiry
// next time it is available. This will happen in the
// putConnection() method.
proxyConnection.markForExpiry(reason);
if (log.isDebugEnabled()) {
log.debug(displayStatistics() + " - #" + FormatHelper.formatMediumNumber(proxyConnection.getId()) + " marked for expiry.");
}
} else {
// So? Kill, kill, kill
// We have to make sure it's null first.
expireProxyConnection(proxyConnection, reasonCode, reason, FORCE_EXPIRY);
}
} // END if (proxyConnection.setOffline())
}
protected void registerRemovedConnection(int status) {
prototyper.connectionRemoved();
connectionCountByState[status]--;
}
/**
* You should {@link #acquireConnectionStatusWriteLock acquire} a write lock
* before calling this method
* @param oldStatus so we know which count to decrement
* @param newStatus so we know which count to increment
*/
protected void changeStatus(int oldStatus, int newStatus) {
// LOG.debug("About to change status");
connectionCountByState[oldStatus]--;
connectionCountByState[newStatus]++;
// LOG.debug("Changing status from " + oldStatus + " to " + newStatus);
// Check to see if shutdown is waiting for all connections to become
// non-active
if (shutdownThread != null && connectionCountByState[ProxyConnectionIF.STATUS_ACTIVE] == 0) {
synchronized (shutdownThread) {
shutdownThread.notify();
}
}
}
public long getConnectionsServedCount() {
return connectionsServedCount;
}
public long getConnectionsRefusedCount() {
return connectionsRefusedCount;
}
protected ConnectionPoolDefinition getDefinition() {
return definition;
}
/**
* Changes both the way that any new connections will be made, and the behaviour of the pool. Consider
* calling expireAllConnections() if you're in a hurry.
*/
protected synchronized void setDefinition(ConnectionPoolDefinition definition) throws ProxoolException {
this.definition = definition;
try {
Class.forName(definition.getDriver());
} catch (ClassNotFoundException e) {
log.error("Couldn't load class " + definition.getDriver(), e);
throw new ProxoolException("Couldn't load class " + definition.getDriver());
} catch (NullPointerException e) {
log.error("Definition did not contain driver", e);
throw new ProxoolException("Definition did not contain driver");
}
}
/**
* @deprecated use {@link #addStateListener(StateListenerIF)} instead.
*/
public void setStateListener(StateListenerIF stateListener) {
addStateListener(stateListener);
}
public void addStateListener(StateListenerIF stateListener) {
this.compositeStateListener.addListener(stateListener);
}
public boolean removeStateListener(StateListenerIF stateListener) {
return this.compositeStateListener.removeListener(stateListener);
}
/**
* @deprecated use {@link #addConnectionListener(ConnectionListenerIF)} instead.
*/
public void setConnectionListener(ConnectionListenerIF connectionListener) {
addConnectionListener(connectionListener);
}
public void addConnectionListener(ConnectionListenerIF connectionListener) {
this.compositeConnectionListener.addListener(connectionListener);
}
public boolean removeConnectionListener(ConnectionListenerIF connectionListener) {
return this.compositeConnectionListener.removeListener(connectionListener);
}
/** Call the onBirth() method on each StateListenerIF . */
protected void onBirth(Connection connection) throws SQLException {
this.compositeConnectionListener.onBirth(connection);
}
/** Call the onDeath() method on each StateListenerIF . */
protected void onDeath(Connection connection, int reasonCode) throws SQLException {
this.compositeConnectionListener.onDeath(connection, reasonCode);
}
/** Call the onExecute() method on each StateListenerIF . */
protected void onExecute(String command, long elapsedTime, Exception exception) throws SQLException {
if (exception == null) {
this.compositeConnectionListener.onExecute(command, elapsedTime);
} else {
this.compositeConnectionListener.onFail(command, exception);
}
}
/**
* Is there a {@link ConnectionListenerIF listener} for connections
* @return true if there is a listener registered.
*/
protected boolean isConnectionListenedTo() {
return !compositeConnectionListener.isEmpty();
}
public String toString() {
return getDefinition().toString();
}
public int getUpState() {
return upState;
}
public void setUpState(int upState) {
if (this.upState != upState) {
compositeStateListener.upStateChanged(upState);
this.upState = upState;
}
}
protected Collection getConnectionInfos() {
Collection cis = null;
cis = new TreeSet();
Iterator i = proxyConnections.iterator();
while (i.hasNext()) {
ConnectionInfoIF connectionInfo = (ConnectionInfoIF) i.next();
ConnectionInfo ci = new ConnectionInfo();
ci.setAge(connectionInfo.getAge());
ci.setBirthDate(connectionInfo.getBirthDate());
ci.setId(connectionInfo.getId());
ci.setMark(connectionInfo.getMark());
ci.setRequester(connectionInfo.getRequester());
ci.setStatus(connectionInfo.getStatus());
ci.setTimeLastStartActive(connectionInfo.getTimeLastStartActive());
ci.setTimeLastStopActive(connectionInfo.getTimeLastStopActive());
ci.setDelegateUrl(connectionInfo.getDelegateUrl());
ci.setProxyHashcode(connectionInfo.getProxyHashcode());
ci.setDelegateHashcode(connectionInfo.getDelegateHashcode());
String[] sqlCalls = connectionInfo.getSqlCalls();
for (int j = 0; j < sqlCalls.length; j++) {
ci.addSqlCall(sqlCalls[j]);
}
cis.add(ci);
}
return cis;
}
/**
* Manually expire a connection.
* @param id the id of the connection to kill
* @param forceExpiry use true to expire even if it is in use
* @return true if the connection was found and expired, else false
*/
public boolean expireConnection(long id, boolean forceExpiry) {
boolean success = false;
ProxyConnection proxyConnection = null;
// We need to look at all the connections, but we don't want to keep looping round forever
for (int connectionsTried = 0; connectionsTried < proxyConnections.size(); connectionsTried++) {
// By doing this in a try/catch we avoid needing to synch on the size(). We need to do be
// able to cope with connections being removed whilst we are going round this loop
try {
proxyConnection = (ProxyConnection) proxyConnections.get(nextAvailableConnection);
} catch (IndexOutOfBoundsException e) {
nextAvailableConnection = 0;
proxyConnection = (ProxyConnection) proxyConnections.get(nextAvailableConnection);
}
if (proxyConnection.getId() == id) {
// This is the one
proxyConnection.setStatus(ProxyConnectionIF.STATUS_AVAILABLE, ProxyConnectionIF.STATUS_OFFLINE);
proxyConnection.setStatus(ProxyConnectionIF.STATUS_OFFLINE, ProxyConnectionIF.STATUS_NULL);
removeProxyConnection(proxyConnection, ConnectionListenerIF.MANUAL_EXPIRY, "it was manually killed", forceExpiry, true);
success = true;
break;
}
nextAvailableConnection++;
}
if (!success) {
if (log.isDebugEnabled()) {
log.debug(displayStatistics() + " - couldn't find " + FormatHelper.formatMediumNumber(proxyConnection.getId())
+ " and I've just been asked to expire it");
}
}
return success;
}
public Log getLog() {
return log;
}
/**
* {@link ConnectionResetter#initialise Initialises} the ConnectionResetter.
* @param connection sample Connection to use for default values
*/
protected void initialiseConnectionResetter(Connection connection) {
connectionResetter.initialise(connection);
}
/**
* {@link ConnectionResetter#reset Resets} a Connection to its
* original state.
* @param connection the one to reset
* @param id the id of the connection
* @throws SQLException if the call to {@link java.sql.Connection#isClosed()} fails
* @return true if it was successfully reset, false if there was a problem (like the connection being already closed)
*/
protected boolean resetConnection(Connection connection, String id) throws SQLException {
if (connection.isClosed()) {
return false;
} else {
return connectionResetter.reset(connection, id);
}
}
/**
* @see ConnectionPoolStatisticsIF#getDateStarted
*/
public Date getDateStarted() {
return dateStarted;
}
/**
* Get the admin for this pool
* @return admin
*/
protected Admin getAdmin() {
return admin;
}
protected boolean isLocked() {
return locked;
}
protected void lock() {
locked = true;
}
protected void unlock() {
locked = false;
}
/**
* Call this if you want to do something important to the pool. Like shut it down.
* @throws InterruptedException if we couldn't
*/
protected void acquirePrimaryReadLock() throws InterruptedException {
// if (log.isDebugEnabled()) {
// try {
// throw new RuntimeException("TRACE ONLY");
// } catch (RuntimeException e) {
// log.debug("About to acquire primary read lock", e);
// }
// // log.debug("About to acquire primary read lock");
// }
primaryReadWriteLock.readLock().acquire();
// if (log.isDebugEnabled()) {
// try {
// throw new RuntimeException("TRACE ONLY");
// } catch (RuntimeException e) {
// log.debug("Acquired primary read lock", e);
// }
// //log.debug("Acquired primary read lock");
// }
}
/**
* @see #acquirePrimaryReadLock
*/
protected void releasePrimaryReadLock() {
// try {
// throw new RuntimeException("TRACE ONLY");
// } catch (RuntimeException e) {
// log.debug("Released primary read lock", e);
// }
//log.debug("Released primary read lock");
primaryReadWriteLock.readLock().release();
}
/**
* Call this everytime you build a connection. It ensures that we're not
* trying to shutdown the pool whilst we are building a connection. So you
* should check that the pool is still {@link #isConnectionPoolUp up}.
* @throws InterruptedException if there was a problem.
*/
protected void acquirePrimaryWriteLock() throws InterruptedException {
// boolean success = false;
// try {
// if (log.isDebugEnabled()) {
// try {
// throw new RuntimeException("TRACE ONLY");
// } catch (RuntimeException e) {
// log.debug("About to acquire primary write lock", e);
// }
// //log.debug("About to acquire primary write lock");
// }
primaryReadWriteLock.writeLock().acquire();
// success = true;
// if (log.isDebugEnabled()) {
// try {
// throw new RuntimeException("TRACE ONLY");
// } catch (RuntimeException e) {
// log.debug("Acquired primary write lock", e);
// }
// //log.debug("Acquired primary write lock");
// }
// } finally {
// if (log.isDebugEnabled() && !success) {
// try {
// throw new RuntimeException("TRACE ONLY");
// } catch (RuntimeException e) {
// log.debug("Failed to acquire primary write lock", e);
// }
// //log.debug("Failed to acquire primary write lock");
// }
// }
}
/**
* @see #acquirePrimaryReadLock
*/
protected void releasePrimaryWriteLock() {
primaryReadWriteLock.writeLock().release();
// try {
// throw new RuntimeException("TRACE ONLY");
// } catch (RuntimeException e) {
// log.debug("Released primary write lock", e);
// }
//log.debug("Released primary write lock");
}
/**
* Is the pool up?
* @return false is the connection pool has been {@link #shutdown shutdown}
* (or is in the process of being shutdown).
*/
protected boolean isConnectionPoolUp() {
return connectionPoolUp;
}
protected static final boolean FORCE_EXPIRY = true;
protected static final boolean REQUEST_EXPIRY = false;
/**
* The time (in milliseconds) that we last refused a connection
* @return timeOfLastRefusal
*/
protected long getTimeOfLastRefusal() {
return timeOfLastRefusal;
}
protected void acquireConnectionStatusWriteLock() {
try {
// try {
// throw new RuntimeException("TRACE ONLY");
// } catch (RuntimeException e) {
// LOG.debug("About to acquire connectionStatus write lock", e);
// }
connectionStatusReadWriteLock.writeLock().acquire();
// try {
// throw new RuntimeException("TRACE ONLY");
// } catch (RuntimeException e) {
// LOG.debug("Acquired connectionStatus write lock", e);
// }
} catch (InterruptedException e) {
log.error("Couldn't acquire connectionStatus write lock", e);
}
}
protected void releaseConnectionStatusWriteLock() {
connectionStatusReadWriteLock.writeLock().release();
// try {
// throw new RuntimeException("TRACE ONLY");
// } catch (RuntimeException e) {
// LOG.debug("Released connectionStatus write lock", e);
// }
}
protected void acquireConnectionStatusReadLock() {
try {
connectionStatusReadWriteLock.readLock().acquire();
} catch (InterruptedException e) {
log.error("Couldn't acquire connectionStatus read lock", e);
}
}
protected boolean attemptConnectionStatusReadLock(long msecs) {
try {
return connectionStatusReadWriteLock.readLock().attempt(msecs);
} catch (InterruptedException e) {
log.error("Couldn't acquire connectionStatus read lock", e);
return false;
}
}
protected void releaseConnectionStatusReadLock() {
connectionStatusReadWriteLock.readLock().release();
// LOG.debug("Released connectionStatus read lock");
}
protected Prototyper getPrototyper() {
return prototyper;
}
public long getConnectionCount() {
return getPrototyper().getConnectionCount();
}
}
/*
Revision history:
$Log: ConnectionPool.java,v $
Revision 1.86 2007/01/25 23:38:24 billhorsman
Scrapped onAboutToDie and altered onDeath signature instead. Now includes reasonCode (see ConnectionListenerIF)
Revision 1.85 2007/01/25 00:10:24 billhorsman
New onAboutToDie event for ConnectionListenerIF that gets called if the maximum-active-time is exceeded.
Revision 1.84 2006/03/23 11:44:57 billhorsman
More information when quickly refusing
Revision 1.83 2006/01/18 14:40:01 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.82 2005/10/07 08:19:05 billhorsman
New sqlCalls gives list of SQL calls rather than just he most recent (for when a connection makes more than one call before being returned to the pool)
Revision 1.81 2005/10/02 12:32:02 billhorsman
Make connectionCount available to statistics
Revision 1.80 2005/09/26 09:54:14 billhorsman
Avoid suspected deadlock when getting a detailed snapshot. Only attempt to get the concurrent lock for 10 seconds before giving up.
Revision 1.79 2005/05/04 16:26:31 billhorsman
Only add a new connection if the definition matches
Revision 1.78 2004/03/25 22:02:15 brenuart
First step towards pluggable ConnectionBuilderIF & ConnectionValidatorIF.
Include some minor refactoring that lead to deprecation of some PrototyperController methods.
Revision 1.76 2004/02/23 17:47:32 billhorsman
Improved message that gets logged if the state change of a connection fails.
Revision 1.75 2004/02/23 17:38:58 billhorsman
Improved message that gets logged if you close a connection more than once.
Revision 1.74 2004/02/12 13:02:17 billhorsman
Catch correct exception when iterating through list.
Revision 1.73 2003/12/09 18:54:55 billhorsman
Make closure of statement during connection test more robust - credit to John Hume
Revision 1.72 2003/11/04 13:52:01 billhorsman
Fixed warning message
Revision 1.71 2003/10/30 00:11:15 billhorsman
Debug info and error logged if unsuccessful attempt to put connection back in pool. Plus connectioninfo comparator changed
Revision 1.70 2003/09/30 18:39:08 billhorsman
New test-before-use, test-after-use and fatal-sql-exception-wrapper-class properties.
Revision 1.69 2003/09/30 07:50:04 billhorsman
Smarter throwing of caught SQLExceptions without wrapping them up inside another (and losing the stack trace)
Revision 1.68 2003/09/20 17:04:06 billhorsman
Fix for incorrect OFFLINE count when house keeper removed a connection if the test SQL failed. This
meant that the offline count went negative. The only consequence of that is that the logs look funny.
Revision 1.67 2003/08/30 14:54:04 billhorsman
Checkstyle
Revision 1.66 2003/04/10 08:23:54 billhorsman
removed very frequent debug
Revision 1.65 2003/03/11 23:58:04 billhorsman
fixed deadlock on connection expiry
Revision 1.64 2003/03/11 14:51:49 billhorsman
more concurrency fixes relating to snapshots
Revision 1.63 2003/03/11 01:16:29 billhorsman
removed misleasing debug
Revision 1.62 2003/03/11 00:32:13 billhorsman
fixed negative timeout
Revision 1.61 2003/03/10 23:39:51 billhorsman
shutdown is now notified when active count reaches
zero
Revision 1.60 2003/03/10 16:26:35 billhorsman
removed debug traces
Revision 1.59 2003/03/10 15:26:44 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.58 2003/03/05 18:42:32 billhorsman
big refactor of prototyping and house keeping to
drastically reduce the number of threads when using
many pools
Revision 1.57 2003/03/03 16:06:44 billhorsman
name house keeper and prototyper threads now includes alias
Revision 1.56 2003/03/03 11:11:57 billhorsman
fixed licence
Revision 1.55 2003/02/28 18:08:55 billhorsman
OVERLOAD state is now triggered immediately rather
than waiting for house keeper
Revision 1.54 2003/02/28 10:10:25 billhorsman
on death now gets called for connections killed during shutdown
Revision 1.53 2003/02/26 16:05:52 billhorsman
widespread changes caused by refactoring the way we
update and redefine pool definitions.
Revision 1.52 2003/02/26 12:57:30 billhorsman
added TO DO
Revision 1.51 2003/02/19 23:46:10 billhorsman
renamed monitor package to admin
Revision 1.50 2003/02/19 23:07:46 billhorsman
state changes are now only calculated every time the house
keeper runs, but it's more accurate
Revision 1.49 2003/02/19 22:38:33 billhorsman
fatal sql exception causes house keeper to run
immediately
Revision 1.48 2003/02/18 16:49:59 chr32
Added possibility to remove connection and state listeners.
Revision 1.47 2003/02/12 12:27:16 billhorsman
log proxy hashcode too
Revision 1.46 2003/02/07 17:26:04 billhorsman
deprecated removeAllConnectionPools in favour of
shutdown (and dropped unreliable finalize() method)
Revision 1.45 2003/02/07 14:19:01 billhorsman
fixed deprecated use of debugLevel property
Revision 1.44 2003/02/07 14:16:46 billhorsman
support for StatisticsListenerIF
Revision 1.43 2003/02/07 10:27:47 billhorsman
change in shutdown procedure to allow re-registration
Revision 1.42 2003/02/07 01:48:15 chr32
Started using new composite listeners.
Revision 1.41 2003/02/06 17:41:04 billhorsman
now uses imported logging
Revision 1.40 2003/02/04 17:18:30 billhorsman
move ShutdownHook init code
Revision 1.39 2003/02/04 15:59:50 billhorsman
finalize now shuts down StatsRoller timer
Revision 1.38 2003/02/02 23:35:48 billhorsman
removed ReloadMonitor to remove use of System properties
Revision 1.37 2003/01/31 16:53:16 billhorsman
checkstyle
Revision 1.36 2003/01/31 11:49:28 billhorsman
use Admin instead of Stats
Revision 1.35 2003/01/31 00:20:05 billhorsman
statistics is now a string to allow multiple,
comma-delimited values (plus better logging of errors
during destruction)
Revision 1.34 2003/01/30 17:22:21 billhorsman
add statistics support
Revision 1.33 2003/01/27 18:26:35 billhorsman
refactoring of ProxyConnection and ProxyStatement to
make it easier to write JDK 1.2 patch
Revision 1.32 2003/01/15 14:51:40 billhorsman
checkstyle
Revision 1.31 2003/01/15 12:01:37 billhorsman
added getDateStarted()
Revision 1.30 2003/01/15 00:07:43 billhorsman
now uses FastArrayList instead of Vector for thread safe
improvements
Revision 1.29 2002/12/18 12:16:22 billhorsman
double checking of connection state counts
Revision 1.28 2002/12/17 17:15:39 billhorsman
Better synchronization of status stuff
Revision 1.27 2002/12/17 16:52:51 billhorsman
synchronize part of removeProxyConnection to avoid
possible bug where connection by status count drifts.
Revision 1.26 2002/12/12 12:28:34 billhorsman
just in case: changed == 0 to < 1
Revision 1.25 2002/12/12 10:48:47 billhorsman
checkstyle
Revision 1.24 2002/12/03 12:24:00 billhorsman
fixed fatal sql exception
Revision 1.23 2002/11/12 20:24:12 billhorsman
checkstyle
Revision 1.22 2002/11/12 20:18:23 billhorsman
Made connection resetter a bit more friendly. Now, if it encounters any problems during
reset then that connection is thrown away. This is going to cause you problems if you
always close connections in an unstable state (e.g. with transactions open. But then
again, it's better to know about that as soon as possible, right?
Revision 1.21 2002/11/09 15:48:55 billhorsman
new isConnectionListenedTo() to stop unnecessary processing
if nobody is listening
Revision 1.20 2002/11/08 18:03:50 billhorsman
when connections are closed because they have been
active for too long then a log message is written
of level WARN, and it includes the name of the
thread responsible (reminder, name your threads).
Revision 1.19 2002/11/07 19:31:25 billhorsman
added sanity check against suspected situation where you
can make more connections than the maximumConnectionCount
Revision 1.18 2002/11/07 19:17:55 billhorsman
removed obsolete method
Revision 1.17 2002/11/06 20:27:30 billhorsman
supports the ConnectionResetter
Revision 1.16 2002/11/05 21:24:18 billhorsman
cosmetic: changed format of statistics dumped to log to make it less confusing for locales that use a space separator for thousands
Revision 1.15 2002/11/02 13:57:33 billhorsman
checkstyle
Revision 1.14 2002/10/30 21:19:17 billhorsman
make use of ProxyFactory
Revision 1.13 2002/10/29 23:00:33 billhorsman
fixed sign error in prototyper (that meant that protoyping never happened)
Revision 1.12 2002/10/29 22:58:22 billhorsman
added connection hashcode to debug
Revision 1.11 2002/10/28 19:44:03 billhorsman
small change to cleanup log
Revision 1.10 2002/10/27 13:02:45 billhorsman
change to prototyper logic to make it clearer (but no functional change)
Revision 1.9 2002/10/27 12:07:45 billhorsman
fix bug where prototyper kept making connections up to maximum. Log now gives reason why connection was prototyped. Fix bug where definition with no properties was not allowed (it is now).
Revision 1.8 2002/10/25 10:12:52 billhorsman
Improvements and fixes to the way connection pools close down. Including new ReloadMonitor to detect when a class is reloaded. Much better logging too.
Revision 1.7 2002/10/24 17:25:20 billhorsman
cleaned up logging and made it more informative
Revision 1.6 2002/10/23 21:04:36 billhorsman
checkstyle fixes (reduced max line width and lenient naming convention
Revision 1.5 2002/10/16 11:46:23 billhorsman
removed obsolete cleanupClob method and made onBirth call failsafe
Revision 1.4 2002/09/19 10:33:57 billhorsman
added ProxyConnection#toString
Revision 1.3 2002/09/18 13:48:56 billhorsman
checkstyle and doc
Revision 1.2 2002/09/13 12:13:50 billhorsman
added debug and fixed ClassCastException during housekeeping
Revision 1.1.1.1 2002/09/13 08:12:55 billhorsman
new
Revision 1.13 2002/08/24 19:57:15 billhorsman
checkstyle changes
Revision 1.12 2002/08/24 19:44:13 billhorsman
fixes for logging
Revision 1.11 2002/07/10 16:14:47 billhorsman
widespread layout changes and move constants into ProxoolConstants
Revision 1.10 2002/07/04 09:05:36 billhorsmaNn
Fixes
Revision 1.9 2002/07/02 11:19:08 billhorsman
layout code and imports
Revision 1.8 2002/07/02 11:14:26 billhorsman
added test (andbug fixes) for FileLogger
Revision 1.7 2002/07/02 08:39:55 billhorsman
getConnectionInfos now returns a Collection instead of an array. displayStatistics is
now available to ProxoolFacade. Prototyper no longer tries to make connections
when maximum is reached (stopping unnecessary log messages). bug fix.
Revision 1.6 2002/06/28 11:19:47 billhorsman
improved doc
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ConnectionPoolDefinition.java 0000644 0001750 0001750 00000141134 10730503124 032312 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.*;
import java.lang.reflect.Modifier;
/**
* This defines a connection pool: the URL to connect to the database, the
* delegate driver to use, and how the pool behaves.
* @version $Revision: 1.36 $, $Date: 2007/07/28 10:39:12 $
* @author billhorsman
* @author $Author: billhorsman $ (current maintainer)
*/
class ConnectionPoolDefinition implements ConnectionPoolDefinitionIF {
// TODO Should we check for defintion reads whilst updating?
private static final Log LOG = LogFactory.getLog(ConnectionPoolDefinition.class);
/**
* This log has a category based on the alias
*/
private Log poolLog = LOG;;
private String alias;
// JNDI properties
private String jndiName;
private String initialContextFactory;
private String providerUrl;
private String securityAuthentication;
private String securityPrincipal;
private String securityCredentials;
private Properties delegateProperties = new Properties();
private Properties completeInfo = new Properties();
private Properties changedInfo = new Properties();
/**
* Whether any of the properties that effect an individual
* connection have changed. If they have, we need to kill
* all the existing connections.
*/
private boolean connectionPropertiesChanged;
private String url;
private String completeUrl;
private String driver;
private long maximumConnectionLifetime;;
private int prototypeCount;
private int minimumConnectionCount;
private int maximumConnectionCount;
private long houseKeepingSleepTime;
private int simultaneousBuildThrottle;
private long recentlyStartedThreshold;
private long overloadWithoutRefusalLifetime;
private long maximumActiveTime;
private boolean verbose;
private boolean trace;
private String statistics;
private String statisticsLogLevel;
private Set fatalSqlExceptions = new HashSet();
/**
* A String of all the fatalSqlExceptions delimited by
* {@link ConnectionPoolDefinitionIF#FATAL_SQL_EXCEPTIONS_DELIMITER}
*/
private String fatalSqlExceptionsAsString;
private String fatalSqlExceptionWrapper = null;
private String houseKeepingTestSql;
private boolean testBeforeUse;
private boolean testAfterUse;
private boolean jmx;
private String jmxAgentId;
private Class injectableConnectionInterface;
private Class injectableStatementInterface;
private Class injectablePreparedStatementInterface;
private Class injectableCallableStatementInterface;
/**
* So we can set the values one by one if we want
*/
public ConnectionPoolDefinition() {
}
/**
* Construct a new definition
* @param url the url that defines this pool
* @param info additional properties (for Proxool and the delegate
* driver)
* @param explicitRegister set to true if we are registering a new pool explicitly, or false
* if it's just because we are serving a url that we haven't come across before
* @throws ProxoolException if anything goes wrong
*/
protected ConnectionPoolDefinition(String url, Properties info, boolean explicitRegister) throws ProxoolException {
this.alias = ProxoolFacade.getAlias(url);
poolLog = LogFactory.getLog("org.logicalcobwebs.proxool." + alias);
reset();
doChange(url, info, false, !explicitRegister);
}
/**
* Update the definition. All existing properties are retained
* and only overwritten if included in the info parameter
* @param url the url that defines this pool
* @param info additional properties (for Proxool and the delegate
* driver)
* @throws ProxoolException if anything goes wrong
*/
protected void update(String url, Properties info) throws ProxoolException {
changedInfo.clear();
connectionPropertiesChanged = false;
poolLog.debug("Updating definition");
doChange(url, info, false, false);
if (connectionPropertiesChanged) {
poolLog.info("Mercifully killing all current connections because of definition changes");
ProxoolFacade.killAllConnections(alias, "of definition changes", true);
}
}
/**
* Redefine the definition. All existing properties are reset to their
* default values
* @param url the url that defines this pool
* @param info additional properties (for Proxool and the delegate
* driver)
* @throws ProxoolException if anything goes wrong
*/
protected void redefine(String url, Properties info) throws ProxoolException {
reset();
changedInfo.clear();
connectionPropertiesChanged = false;
poolLog.debug("Redefining definition");
doChange(url, info, false, false);
// Check for minimum information
if (getUrl() == null || getDriver() == null) {
throw new ProxoolException("The URL is not defined properly: " + getCompleteUrl());
}
if (connectionPropertiesChanged) {
LOG.info("Mercifully killing all current connections because of definition changes");
ProxoolFacade.killAllConnections(alias, "definition has changed", true);
}
}
private boolean doChange(String url, Properties info, boolean pretend, boolean implicitRegister) throws ProxoolException {
boolean changed = false;
try {
int endOfPrefix = url.indexOf(':');
int endOfDriver = url.indexOf(':', endOfPrefix + 1);
if (endOfPrefix > -1 && endOfDriver > -1) {
final String driver = url.substring(endOfPrefix + 1, endOfDriver);
if (isChanged(getDriver(), driver)) {
changed = true;
if (!pretend) {
logChange(true, ProxoolConstants.DELEGATE_DRIVER_PROPERTY, driver);
setDriver(driver);
}
}
final String delegateUrl = url.substring(endOfDriver + 1);
if (isChanged(getUrl(), delegateUrl)) {
changed = true;
if (!pretend) {
logChange(true, ProxoolConstants.DELEGATE_URL_PROPERTY, delegateUrl);
setUrl(delegateUrl);
}
}
} else {
// Using alias. Nothing to do
}
} catch (IndexOutOfBoundsException e) {
LOG.error("Invalid URL: '" + url + "'", e);
throw new ProxoolException("Invalid URL: '" + url + "'");
}
if (!pretend) {
setCompleteUrl(url);
}
if (info != null) {
Enumeration e = info.propertyNames();
while (e.hasMoreElements()) {
String key = (String) e.nextElement();
String value = info.getProperty(key);
changed = changed | setAnyProperty(key, value, pretend);
if (!pretend) {
completeInfo.setProperty(key, value);
}
}
}
if (!pretend) {
ProxoolFacade.definitionUpdated(getAlias(), this, completeInfo, changedInfo);
}
if ((getDriver() == null || getUrl() == null) && implicitRegister) {
throw new ProxoolException("Attempt to refer to a unregistered pool by its alias '" + getAlias() + "'");
}
return changed;
}
private void logChange(boolean proxoolProperty, String key, String value) {
if (poolLog.isDebugEnabled()) {
String displayValue = value;
if (key.toLowerCase().indexOf("password") > -1) {
displayValue = "********";
}
poolLog.debug((proxoolProperty ? "Recognised proxool property: " : "Delegating property to driver: ") + key + "=" + displayValue);
}
}
private boolean setAnyProperty(String key, String value, boolean pretend) throws ProxoolException {
boolean proxoolProperty = true;
boolean changed = false;
// These groups of properties have been split off to make this method smaller
changed = changed || setHouseKeeperProperty(key, value, pretend);
changed = changed || setLoggingProperty(key, value, pretend);
changed = changed || setInjectableProperty(key, value, pretend);
changed = changed || setJndiProperty(key, value, pretend);
if (key.equals(ProxoolConstants.USER_PROPERTY)) {
proxoolProperty = false;
if (isChanged(getUser(), value)) {
changed = true;
if (!pretend) {
setUser(value);
}
}
} else if (key.equals(ProxoolConstants.PASSWORD_PROPERTY)) {
proxoolProperty = false;
if (isChanged(getPassword(), value)) {
changed = true;
if (!pretend) {
setPassword(value);
}
}
} else if (key.equals(ProxoolConstants.DELEGATE_DRIVER_PROPERTY)) {
if (isChanged(getDriver(), value)) {
changed = true;
if (!pretend) {
setDriver(value);
}
}
} else if (key.equals(ProxoolConstants.DELEGATE_URL_PROPERTY)) {
if (isChanged(getUrl(), value)) {
changed = true;
if (!pretend) {
setUrl(value);
}
}
} else if (key.equals(ProxoolConstants.MAXIMUM_CONNECTION_COUNT_PROPERTY)) {
if (getMaximumConnectionCount() != getInt(key, value)) {
changed = true;
if (!pretend) {
setMaximumConnectionCount(getInt(key, value));
}
}
} else if (key.equals(ProxoolConstants.MAXIMUM_CONNECTION_LIFETIME_PROPERTY)) {
if (getMaximumConnectionLifetime() != getLong(key, value)) {
changed = true;
if (!pretend) {
setMaximumConnectionLifetime(getLong(key, value));
}
}
} else if (key.equals(ProxoolConstants.MAXIMUM_NEW_CONNECTIONS_PROPERTY)) {
poolLog.warn("Use of " + ProxoolConstants.MAXIMUM_NEW_CONNECTIONS_PROPERTY + " is deprecated. Use more descriptive " + ProxoolConstants.SIMULTANEOUS_BUILD_THROTTLE_PROPERTY + " instead.");
if (getSimultaneousBuildThrottle() != getInt(key, value)) {
changed = true;
if (!pretend) {
setSimultaneousBuildThrottle(getInt(key, value));
}
}
} else if (key.equals(ProxoolConstants.SIMULTANEOUS_BUILD_THROTTLE_PROPERTY)) {
if (getSimultaneousBuildThrottle() != getInt(key, value)) {
changed = true;
setSimultaneousBuildThrottle(getInt(key, value));
}
} else if (key.equals(ProxoolConstants.MINIMUM_CONNECTION_COUNT_PROPERTY)) {
if (getMinimumConnectionCount() != getInt(key, value)) {
changed = true;
if (!pretend) {
setMinimumConnectionCount(getInt(key, value));
}
}
} else if (key.equals(ProxoolConstants.PROTOTYPE_COUNT_PROPERTY)) {
if (getPrototypeCount() != getInt(key, value)) {
changed = true;
if (!pretend) {
setPrototypeCount(getInt(key, value));
}
}
} else if (key.equals(ProxoolConstants.RECENTLY_STARTED_THRESHOLD_PROPERTY)) {
if (getRecentlyStartedThreshold() != getLong(key, value)) {
changed = true;
if (!pretend) {
setRecentlyStartedThreshold(getLong(key, value));
}
}
} else if (key.equals(ProxoolConstants.OVERLOAD_WITHOUT_REFUSAL_LIFETIME_PROPERTY)) {
if (getOverloadWithoutRefusalLifetime() != getLong(key, value)) {
changed = true;
if (!pretend) {
setOverloadWithoutRefusalLifetime(getLong(key, value));
}
}
} else if (key.equals(ProxoolConstants.MAXIMUM_ACTIVE_TIME_PROPERTY)) {
if (getMaximumActiveTime() != getLong(key, value)) {
changed = true;
if (!pretend) {
setMaximumActiveTime(getLong(key, value));
}
}
} else if (key.equals(ProxoolConstants.FATAL_SQL_EXCEPTION_PROPERTY)) {
if (isChanged(fatalSqlExceptionsAsString, value)) {
changed = true;
if (!pretend) {
setFatalSqlExceptionsAsString(value.length() > 0 ? value : null);
}
}
} else if (key.equals(ProxoolConstants.FATAL_SQL_EXCEPTION_WRAPPER_CLASS_PROPERTY)) {
if (isChanged(fatalSqlExceptionWrapper, value)) {
changed = true;
if (!pretend) {
setFatalSqlExceptionWrapper(value.length() > 0 ? value : null);
}
}
} else if (key.equals(ProxoolConstants.STATISTICS_PROPERTY)) {
if (isChanged(getStatistics(), value)) {
changed = true;
if (!pretend) {
setStatistics(value.length() > 0 ? value : null);
}
}
} else if (key.equals(ProxoolConstants.STATISTICS_LOG_LEVEL_PROPERTY)) {
if (isChanged(getStatisticsLogLevel(), value)) {
changed = true;
if (!pretend) {
setStatisticsLogLevel(value.length() > 0 ? value : null);
}
}
}
if (!key.startsWith(ProxoolConstants.PROPERTY_PREFIX)) {
if (isChanged(getDelegateProperty(key), value)) {
changed = true;
if (!pretend) {
setDelegateProperty(key, value);
}
}
proxoolProperty = false;
}
if (changed && !pretend) {
logChange(proxoolProperty, key, value);
changedInfo.setProperty(key, value);
}
return changed;
}
/**
* Subset of {@link #setAnyProperty} to avoid overly long method
* @see #setAnyProperty
*/
private boolean setLoggingProperty(String key, String value, boolean pretend) {
boolean changed = false;
if (key.equals(ProxoolConstants.DEBUG_LEVEL_PROPERTY)) {
if (value != null && value.equals("1")) {
poolLog.warn("Use of " + ProxoolConstants.DEBUG_LEVEL_PROPERTY + "=1 is deprecated. Use " + ProxoolConstants.VERBOSE_PROPERTY + "=true instead.");
if (!isVerbose()) {
changed = true;
if (!pretend) {
setVerbose(true);
}
}
} else {
poolLog.warn("Use of " + ProxoolConstants.DEBUG_LEVEL_PROPERTY + "=0 is deprecated. Use " + ProxoolConstants.VERBOSE_PROPERTY + "=false instead.");
if (isVerbose()) {
changed = true;
if (!pretend) {
setVerbose(false);
}
}
}
} else if (key.equals(ProxoolConstants.VERBOSE_PROPERTY)) {
final boolean valueAsBoolean = Boolean.valueOf(value).booleanValue();
if (isVerbose() != valueAsBoolean) {
changed = true;
if (!pretend) {
setVerbose(valueAsBoolean);
}
}
} else if (key.equals(ProxoolConstants.TRACE_PROPERTY)) {
final boolean valueAsBoolean = Boolean.valueOf(value).booleanValue();
if (isTrace() != valueAsBoolean) {
changed = true;
if (!pretend) {
setTrace(valueAsBoolean);
}
}
}
return changed;
}
/**
* Subset of {@link #setAnyProperty} to avoid overly long method
* @see #setAnyProperty
*/
private boolean setInjectableProperty(String key, String value, boolean pretend) {
boolean changed = false;
if (key.equals(ProxoolConstants.INJECTABLE_CONNECTION_INTERFACE_NAME_PROPERTY)) {
if (isChanged(getInjectableConnectionInterfaceName(), value)) {
changed = true;
if (!pretend) {
setInjectableConnectionInterfaceName(value.length() > 0 ? value : null);
}
}
} else if (key.equals(ProxoolConstants.INJECTABLE_STATEMENT_INTERFACE_NAME_PROPERTY)) {
if (isChanged(getInjectableStatementInterfaceName(), value)) {
changed = true;
if (!pretend) {
setInjectableStatementInterfaceName(value.length() > 0 ? value : null);
}
}
} else if (key.equals(ProxoolConstants.INJECTABLE_PREPARED_STATEMENT_INTERFACE_NAME_PROPERTY)) {
if (isChanged(getInjectablePreparedStatementInterfaceName(), value)) {
changed = true;
if (!pretend) {
setInjectablePreparedStatementInterfaceName(value.length() > 0 ? value : null);
}
}
} else if (key.equals(ProxoolConstants.INJECTABLE_CALLABLE_STATEMENT_INTERFACE_NAME_PROPERTY)) {
if (isChanged(getInjectableCallableStatememtInterfaceName(), value)) {
changed = true;
if (!pretend) {
setInjectableCallableStatementInterfaceName(value.length() > 0 ? value : null);
}
}
}
return changed;
}
/**
* Subset of {@link #setAnyProperty} to avoid overly long method.
* @see #setAnyProperty
*/
private boolean setHouseKeeperProperty(String key, String value, boolean pretend) throws ProxoolException {
boolean changed = false;
if (key.equals(ProxoolConstants.HOUSE_KEEPING_SLEEP_TIME_PROPERTY)) {
if (getHouseKeepingSleepTime() != getLong(key, value)) {
changed = true;
if (!pretend) {
setHouseKeepingSleepTime(getLong(key, value));
}
}
} else if (key.equals(ProxoolConstants.HOUSE_KEEPING_TEST_SQL_PROPERTY)) {
if (isChanged(getHouseKeepingTestSql(), value)) {
changed = true;
if (!pretend) {
setHouseKeepingTestSql(value.length() > 0 ? value : null);
}
}
} else if (key.equals(ProxoolConstants.TEST_BEFORE_USE_PROPERTY)) {
final boolean valueAsBoolean = Boolean.valueOf(value).booleanValue();
if (isTestBeforeUse() != valueAsBoolean) {
changed = true;
if (!pretend) {
setTestBeforeUse(valueAsBoolean);
}
}
} else if (key.equals(ProxoolConstants.TEST_AFTER_USE_PROPERTY)) {
final boolean valueAsBoolean = Boolean.valueOf(value).booleanValue();
if (isTestAfterUse() != valueAsBoolean) {
changed = true;
if (!pretend) {
setTestAfterUse(valueAsBoolean);
}
}
}
return changed;
}
/**
* Subset of {@link #setAnyProperty} to avoid overly long method
* @see #setAnyProperty
*/
private boolean setJndiProperty(String key, String value, boolean pretend) {
boolean changed = false;
if (key.equals(ProxoolConstants.JNDI_NAME_PROPERTY)) {
if (isChanged(getJndiName(), value)) {
changed = true;
if (!pretend) {
setJndiName(value.length() > 0 ? value : null);
}
}
} else {
}
return changed;
}
private int getInt(String key, String value) throws ProxoolException {
try {
return Integer.parseInt(value);
} catch (NumberFormatException e) {
throw new ProxoolException("'" + key + "' property must be an integer. Found '" + value + "' instead.");
}
}
private long getLong(String key, String value) throws ProxoolException {
try {
return Long.parseLong(value);
} catch (NumberFormatException e) {
throw new ProxoolException("'" + key + "' property must be a long. Found '" + value + "' instead.");
}
}
private static boolean isChanged(String oldValue, String newValue) {
boolean changed = false;
if (oldValue == null) {
if (newValue != null) {
changed = true;
}
} else if (newValue == null) {
changed = true;
} else if (!oldValue.equals(newValue)) {
changed = true;
}
return changed;
}
/**
* Deep clone of definition
* @return the new definition
* @throws CloneNotSupportedException
*/
protected Object clone() throws CloneNotSupportedException {
ConnectionPoolDefinition clone = new ConnectionPoolDefinition();
clone.setCompleteUrl(completeUrl);
clone.setDelegateProperties((Properties) delegateProperties.clone());
clone.setCompleteInfo((Properties) completeInfo.clone());
clone.clearChangedInfo();
clone.setAlias(alias);
clone.setUrl(url);
clone.setDriver(driver);
clone.setMaximumConnectionLifetime(maximumConnectionLifetime);
clone.setPrototypeCount(prototypeCount);
clone.setMinimumConnectionCount(minimumConnectionCount);
clone.setMaximumConnectionCount(maximumConnectionCount);
clone.setHouseKeepingSleepTime(houseKeepingSleepTime);
clone.setHouseKeepingTestSql(houseKeepingTestSql);
clone.setTestAfterUse(testAfterUse);
clone.setTestBeforeUse(testBeforeUse);
clone.setSimultaneousBuildThrottle(simultaneousBuildThrottle);
clone.setRecentlyStartedThreshold(recentlyStartedThreshold);
clone.setOverloadWithoutRefusalLifetime(overloadWithoutRefusalLifetime);
clone.setMaximumActiveTime(maximumActiveTime);
clone.setVerbose(verbose);
clone.setTrace(trace);
clone.setStatistics(statistics);
clone.setStatisticsLogLevel(statisticsLogLevel);
clone.setFatalSqlExceptionsAsString(fatalSqlExceptionsAsString);
try {
clone.setFatalSqlExceptionWrapper(fatalSqlExceptionWrapper);
} catch (ProxoolException e) {
throw new IllegalArgumentException("Problem cloning fatalSqlExceptionWrapper: " + fatalSqlExceptionWrapper);
}
return clone;
}
private void clearChangedInfo() {
changedInfo.clear();
}
/**
* Reset all properties to their default values
*/
private void reset() {
completeUrl = null;
delegateProperties.clear();
completeInfo.clear();
changedInfo.clear();
url = null;
driver = null;
maximumConnectionLifetime = DEFAULT_MAXIMUM_CONNECTION_LIFETIME;
prototypeCount = DEFAULT_PROTOTYPE_COUNT;
minimumConnectionCount = DEFAULT_MINIMUM_CONNECTION_COUNT;
maximumConnectionCount = DEFAULT_MAXIMUM_CONNECTION_COUNT;
houseKeepingSleepTime = DEFAULT_HOUSE_KEEPING_SLEEP_TIME;
houseKeepingTestSql = null;
testAfterUse = false;
testBeforeUse = false;
simultaneousBuildThrottle = DEFAULT_SIMULTANEOUS_BUILD_THROTTLE;
recentlyStartedThreshold = DEFAULT_RECENTLY_STARTED_THRESHOLD;
overloadWithoutRefusalLifetime = DEFAULT_OVERLOAD_WITHOUT_REFUSAL_THRESHOLD;
maximumActiveTime = DEFAULT_MAXIMUM_ACTIVE_TIME;
verbose = false;
trace = false;
statistics = null;
statisticsLogLevel = null;
fatalSqlExceptions.clear();
fatalSqlExceptionWrapper = null;
}
/**
* Get all the properties used to define this pool
* @return
*/
protected Properties getCompleteInfo() {
return completeInfo;
}
/**
* Overwrite the complete info
* @param completeInfo the new properties
* @see #getCompleteInfo()
*/
public void setCompleteInfo(Properties completeInfo) {
this.completeInfo = completeInfo;
}
/**
* @see ConnectionPoolDefinitionIF#getUser
*/
public String getUser() {
return getDelegateProperty(USER_PROPERTY);
}
/**
* @see ConnectionPoolDefinitionIF#getUser
*/
public void setUser(String user) {
setDelegateProperty(USER_PROPERTY, user);
}
/**
* @see ConnectionPoolDefinitionIF#getPassword
*/
public String getPassword() {
return getDelegateProperty(PASSWORD_PROPERTY);
}
/**
* @see ConnectionPoolDefinitionIF#getPassword
*/
public void setPassword(String password) {
setDelegateProperty(PASSWORD_PROPERTY, password);
}
/**
* @see ConnectionPoolDefinitionIF#getJdbcDriverVersion
*/
public String getJdbcDriverVersion() {
try {
Driver driver = DriverManager.getDriver(getUrl());
return driver.getMajorVersion() + "." + driver.getMinorVersion();
} catch (SQLException e) {
return "Trying to locate driver version for '" + getUrl() + "' caused: " + e.toString();
} catch (NullPointerException e) {
return "Couldn't locate driver for '" + getUrl() + "'!";
}
}
/**
* @see Object#toString
*/
public String toString() {
return getCompleteUrl();
}
/**
* @see ConnectionPoolDefinitionIF#getName
* @deprecated use {@link #getAlias}
*/
public String getName() {
return alias;
}
/**
* @see ConnectionPoolDefinitionIF#getAlias
*/
public String getAlias() {
return alias;
}
/**
* @see ConnectionPoolDefinitionIF#getAlias
*/
public void setAlias(String alias) {
this.alias = alias;
}
/**
* @see ConnectionPoolDefinitionIF#getMaximumConnectionLifetime
*/
public long getMaximumConnectionLifetime() {
return maximumConnectionLifetime;
}
/**
* @see ConnectionPoolDefinitionIF#getMaximumConnectionLifetime
*/
public void setMaximumConnectionLifetime(long maximumConnectionLifetime) {
this.maximumConnectionLifetime = maximumConnectionLifetime;
}
/**
* @see ConnectionPoolDefinitionIF#getPrototypeCount
*/
public int getPrototypeCount() {
return prototypeCount;
}
/**
* @see ConnectionPoolDefinitionIF#getPrototypeCount
*/
public void setPrototypeCount(int prototypeCount) {
this.prototypeCount = prototypeCount;
}
/**
* @see ConnectionPoolDefinitionIF#getMinimumConnectionCount
*/
public int getMinimumConnectionCount() {
return minimumConnectionCount;
}
/**
* @see ConnectionPoolDefinitionIF#getMinimumConnectionCount
*/
public void setMinimumConnectionCount(int minimumConnectionCount) {
this.minimumConnectionCount = minimumConnectionCount;
}
/**
* @see ConnectionPoolDefinitionIF#getMaximumConnectionCount
*/
public int getMaximumConnectionCount() {
return maximumConnectionCount;
}
/**
* @see ConnectionPoolDefinitionIF#getMaximumConnectionCount
*/
public void setMaximumConnectionCount(int maximumConnectionCount) {
this.maximumConnectionCount = maximumConnectionCount;
}
/**
* @see ConnectionPoolDefinitionIF#getHouseKeepingSleepTime
*/
public long getHouseKeepingSleepTime() {
return houseKeepingSleepTime;
}
/**
* @see ConnectionPoolDefinitionIF#getHouseKeepingSleepTime
*/
public void setHouseKeepingSleepTime(long houseKeepingSleepTime) {
this.houseKeepingSleepTime = houseKeepingSleepTime;
}
/**
* @see ConnectionPoolDefinitionIF#getMaximumNewConnections
* @deprecated use more descriptive {@link #getSimultaneousBuildThrottle} instead
*/
public int getMaximumNewConnections() {
return simultaneousBuildThrottle;
}
/**
* @see ConnectionPoolDefinitionIF#getMaximumNewConnections
* @deprecated use more descriptive {@link #setSimultaneousBuildThrottle} instead
*/
public void setMaximumNewConnections(int maximumNewConnections) {
this.simultaneousBuildThrottle = maximumNewConnections;
}
/**
* @see ConnectionPoolDefinitionIF#getSimultaneousBuildThrottle
*/
public int getSimultaneousBuildThrottle() {
return simultaneousBuildThrottle;
}
/**
* @see ConnectionPoolDefinitionIF#getSimultaneousBuildThrottle
*/
public void setSimultaneousBuildThrottle(int simultaneousBuildThrottle) {
this.simultaneousBuildThrottle = simultaneousBuildThrottle;
}
/**
* @see ConnectionPoolDefinitionIF#getProperties
* @deprecated use less ambiguous {@link #getDelegateProperties} instead
*/
public Properties getProperties() {
return delegateProperties;
}
/**
* @see ConnectionPoolDefinitionIF#getDelegateProperties
*/
public Properties getDelegateProperties() {
return delegateProperties;
}
/**
* Get a property
* @param name the name of the property
* @return the value of the property
*/
public String getDelegateProperty(String name) {
return getDelegateProperties().getProperty(name);
}
/**
* Set a property
* @param name the name of the property
* @param value the value of the property
* @see ConnectionPoolDefinitionIF#getProperties
*/
public void setDelegateProperty(String name, String value) {
connectionPropertiesChanged = true;
getDelegateProperties().setProperty(name, value);
}
/**
* Overwrite the delegate properties
* @param delegateProperties the new properties
* @see ConnectionPoolDefinitionIF#getProperties
*/
public void setDelegateProperties(Properties delegateProperties) {
this.delegateProperties = delegateProperties;
}
/**
* @see ConnectionPoolDefinitionIF#getUrl
*/
public String getUrl() {
return url;
}
/**
* @see ConnectionPoolDefinitionIF#getUrl
*/
public void setUrl(String url) {
this.url = url;
connectionPropertiesChanged = true;
}
/**
* @see ConnectionPoolDefinitionIF#getDriver
*/
public String getDriver() {
return driver;
}
/**
* @see ConnectionPoolDefinitionIF#getDriver
*/
public void setDriver(String driver) {
this.driver = driver;
connectionPropertiesChanged = true;
}
/**
* @see ConnectionPoolDefinitionIF#getRecentlyStartedThreshold
*/
public long getRecentlyStartedThreshold() {
return recentlyStartedThreshold;
}
/**
* @see ConnectionPoolDefinitionIF#getRecentlyStartedThreshold
*/
public void setRecentlyStartedThreshold(long recentlyStartedThreshold) {
this.recentlyStartedThreshold = recentlyStartedThreshold;
}
/**
* @see ConnectionPoolDefinitionIF#getOverloadWithoutRefusalLifetime
*/
public long getOverloadWithoutRefusalLifetime() {
return overloadWithoutRefusalLifetime;
}
/**
* @see ConnectionPoolDefinitionIF#getOverloadWithoutRefusalLifetime
*/
public void setOverloadWithoutRefusalLifetime(long overloadWithoutRefusalLifetime) {
this.overloadWithoutRefusalLifetime = overloadWithoutRefusalLifetime;
}
/**
* @see ConnectionPoolDefinitionIF#getMaximumActiveTime
*/
public long getMaximumActiveTime() {
return maximumActiveTime;
}
/**
* @see ConnectionPoolDefinitionIF#getMaximumActiveTime
*/
public void setMaximumActiveTime(long maximumActiveTime) {
this.maximumActiveTime = maximumActiveTime;
}
/**
* @see ConnectionPoolDefinitionIF#getDebugLevel
* @deprecated use {@link #isVerbose} instead
*/
public int getDebugLevel() {
return (verbose ? 1 : 0);
}
/**
* @see ConnectionPoolDefinitionIF#isVerbose
*/
public boolean isVerbose() {
return verbose;
}
/**
* @see ConnectionPoolDefinitionIF#isVerbose
*/
public void setVerbose(boolean verbose) {
this.verbose = verbose;
}
/**
* @see ConnectionPoolDefinitionIF#isTrace
*/
public boolean isTrace() {
return trace;
}
/**
* @see ConnectionPoolDefinitionIF#isTrace
*/
public void setTrace(boolean trace) {
this.trace = trace;
}
/**
* @see ConnectionPoolDefinitionIF#getCompleteUrl
*/
public String getCompleteUrl() {
return completeUrl;
}
/**
* @see ConnectionPoolDefinitionIF#getCompleteUrl
*/
public void setCompleteUrl(String completeUrl) {
this.completeUrl = completeUrl;
}
/**
* @see ConnectionPoolDefinitionIF#getFatalSqlExceptions
*/
public void setFatalSqlExceptionsAsString(String fatalSqlExceptionsAsString) {
this.fatalSqlExceptionsAsString = fatalSqlExceptionsAsString;
fatalSqlExceptions.clear();
if (fatalSqlExceptionsAsString != null) {
StringTokenizer st = new StringTokenizer(fatalSqlExceptionsAsString, FATAL_SQL_EXCEPTIONS_DELIMITER);
while (st.hasMoreTokens()) {
fatalSqlExceptions.add(st.nextToken().trim());
}
}
}
/**
* @see ConnectionPoolDefinitionIF#getFatalSqlExceptions
*/
public Set getFatalSqlExceptions() {
return fatalSqlExceptions;
}
/**
* @see ConnectionPoolDefinitionIF#getFatalSqlExceptionWrapper
*/
public String getFatalSqlExceptionWrapper() {
return fatalSqlExceptionWrapper;
}
/**
* @see ConnectionPoolDefinitionIF#getFatalSqlExceptionWrapper
*/
public void setFatalSqlExceptionWrapper(String fatalSqlExceptionWrapper) throws ProxoolException {
// Test it out. That's the best way.
try {
FatalSqlExceptionHelper.throwFatalSQLException(fatalSqlExceptionWrapper, new SQLException("Test"));
} catch (SQLException e) {
// That's OK, we were expecting one of these
} catch (RuntimeException e) {
// That's OK, we were expecting one of these
}
this.fatalSqlExceptionWrapper = fatalSqlExceptionWrapper;
}
/**
* @see ConnectionPoolDefinitionIF#getHouseKeepingTestSql
*/
public String getHouseKeepingTestSql() {
return houseKeepingTestSql;
}
/**
* @see ConnectionPoolDefinitionIF#getHouseKeepingTestSql
*/
public void setHouseKeepingTestSql(String houseKeepingTestSql) {
this.houseKeepingTestSql = houseKeepingTestSql;
}
/**
* @see ConnectionPoolDefinitionIF#isTestBeforeUse
*/
public boolean isTestBeforeUse() {
return testBeforeUse;
}
/**
* @see ConnectionPoolDefinitionIF#isTestBeforeUse
*/
public void setTestBeforeUse(boolean testBeforeUse) {
this.testBeforeUse = testBeforeUse;
}
/**
* @see ConnectionPoolDefinitionIF#isTestAfterUse
*/
public boolean isTestAfterUse() {
return testAfterUse;
}
/**
* @see ConnectionPoolDefinitionIF#isTestAfterUse
*/
public void setTestAfterUse(boolean testAfterUse) {
this.testAfterUse = testAfterUse;
}
/**
* @see ConnectionPoolDefinitionIF#getStatistics
*/
public String getStatistics() {
return statistics;
}
/**
* @see ConnectionPoolDefinitionIF#getStatistics
*/
public void setStatistics(String statistics) {
this.statistics = statistics;
}
/**
* @see ConnectionPoolDefinitionIF#getStatisticsLogLevel
*/
public String getStatisticsLogLevel() {
return statisticsLogLevel;
}
/**
* @see ConnectionPoolDefinitionIF#getStatisticsLogLevel
*/
public void setStatisticsLogLevel(String statisticsLogLevel) {
this.statisticsLogLevel = statisticsLogLevel;
}
// Start JNDI
public String getJndiName() {
return jndiName;
}
public void setJndiName(String jndiName) {
this.jndiName = jndiName;
}
public String getInitialContextFactory() {
return initialContextFactory;
}
public void setInitialContextFactory(String initialContextFactory) {
this.initialContextFactory = initialContextFactory;
}
public String getProviderUrl() {
return providerUrl;
}
public void setProviderUrl(String providerUrl) {
this.providerUrl = providerUrl;
}
public String getSecurityAuthentication() {
return securityAuthentication;
}
public void setSecurityAuthentication(String securityAuthentication) {
this.securityAuthentication = securityAuthentication;
}
public String getSecurityPrincipal() {
return securityPrincipal;
}
public void setSecurityPrincipal(String securityPrincipal) {
this.securityPrincipal = securityPrincipal;
}
public String getSecurityCredentials() {
return securityCredentials;
}
public void setSecurityCredentials(String securityCredentials) {
this.securityCredentials = securityCredentials;
}
// End JNDI
/**
* @see ConnectionPoolDefinitionIF#isJmx()
*/
public boolean isJmx() {
return jmx;
}
/**
* @see ConnectionPoolDefinitionIF#isJmx()
*/
public void setJmx(boolean jmx) {
this.jmx = jmx;
}
/**
* @see ConnectionPoolDefinitionIF#getJmxAgentId()
*/
public String getJmxAgentId() {
return jmxAgentId;
}
/**
* @see ConnectionPoolDefinitionIF#getJmxAgentId()
*/
public void setJmxAgentId(String jmxAgentId) {
this.jmxAgentId = jmxAgentId;
}
/**
* @see ConnectionPoolDefinitionIF#getInjectableConnectionInterface()
*/
public Class getInjectableConnectionInterface() {
return injectableConnectionInterface;
}
/**
* @see ConnectionPoolDefinitionIF#getInjectableConnectionInterface()
*/
public String getInjectableConnectionInterfaceName() {
if (getInjectableConnectionInterface() != null) {
return getInjectableConnectionInterface().getName();
} else {
return null;
}
}
/**
* @param injectableConnectionInterfaceName the fully qualified class name
* @see ConnectionPoolDefinitionIF#getInjectableConnectionInterface()
*/
public void setInjectableConnectionInterfaceName(String injectableConnectionInterfaceName) {
this.injectableConnectionInterface = getInterface(injectableConnectionInterfaceName);
}
/**
* @see ConnectionPoolDefinitionIF#getInjectableStatementInterface()
*/
public Class getInjectableStatementInterface() {
return injectableStatementInterface;
}
/**
* @see ConnectionPoolDefinitionIF#getInjectableStatementInterface()
*/
public String getInjectableStatementInterfaceName() {
if (getInjectableStatementInterface() != null) {
return getInjectableStatementInterface().getName();
} else {
return null;
}
}
/**
* @param injectableStatementInterfaceName the fully qualified class name
* @see ConnectionPoolDefinitionIF#getInjectableStatementInterface()
*/
public void setInjectableStatementInterfaceName(String injectableStatementInterfaceName) {
this.injectableStatementInterface = getInterface(injectableStatementInterfaceName);
}
/**
* @see ConnectionPoolDefinitionIF#getInjectablePreparedStatementInterface()
*/
public Class getInjectablePreparedStatementInterface() {
return injectablePreparedStatementInterface;
}
/**
* @see ConnectionPoolDefinitionIF#getInjectablePreparedStatementInterface()
*/
public String getInjectablePreparedStatementInterfaceName() {
if (getInjectablePreparedStatementInterface() != null) {
return getInjectablePreparedStatementInterface().getName();
} else {
return null;
}
}
/**
* @param injectablePreparedStatementInterfaceName the fully qualified class name
* @see ConnectionPoolDefinitionIF#getInjectablePreparedStatementInterface()
*/
public void setInjectablePreparedStatementInterfaceName(String injectablePreparedStatementInterfaceName) {
this.injectablePreparedStatementInterface = getInterface(injectablePreparedStatementInterfaceName);
}
/**
* @see ConnectionPoolDefinitionIF#getInjectableCallableStatementInterface()
*/
public String getInjectableCallableStatememtInterfaceName() {
if (getInjectableCallableStatementInterface() != null) {
return getInjectableCallableStatementInterface().getName();
} else {
return null;
}
}
/**
* @see ConnectionPoolDefinitionIF#getInjectableCallableStatementInterface()
*/
public Class getInjectableCallableStatementInterface() {
return injectableCallableStatementInterface;
}
/**
* @param injectableCallableStatementInterfaceName the fully qualified class name
* @see ConnectionPoolDefinitionIF#getInjectableCallableStatementInterface()
*/
public void setInjectableCallableStatementInterfaceName(String injectableCallableStatementInterfaceName) {
this.injectableCallableStatementInterface = getInterface(injectableCallableStatementInterfaceName);
}
private Class getInterface(String className) {
try {
Class clazz = null;
if (className != null && className.length() > 0) {
clazz = Class.forName(className);
if (!clazz.isInterface()) {
throw new IllegalArgumentException(className + " is a class. It must be an interface.");
}
if (!Modifier.isPublic(clazz.getModifiers())) {
throw new IllegalArgumentException(className + " is a protected interface. It must be public.");
}
}
return clazz;
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException(className + " couldn't be found");
}
}
/**
* Returns true if {@link #redefine redefining} the pool using
* these parameters would not change the definition. You can
* use this to decide whether or not to trigger a change
* {@link ConfigurationListenerIF#definitionUpdated event}.
*
* @param url the url (containing alias and possible delegate url and driver)
* @param info the properties
* @return true if the definition is identical to that that represented by these parameters
*/
public boolean isEqual(String url, Properties info) {
try {
return !doChange(url, info, true, false);
} catch (ProxoolException e) {
LOG.error("Problem checking equality", e);
return false;
}
/*
boolean equal = true;
if (info == null && completeInfo != null) {
equal = false;
} else if (info != null && completeInfo == null) {
equal = false;
} else if (!info.equals(completeInfo)) {
equal = false;
} else if (!url.equals(completeUrl)) {
equal = false;
}
return equal;
*/
}
}
/*
Revision history:
$Log: ConnectionPoolDefinition.java,v $
Revision 1.36 2007/07/28 10:39:12 billhorsman
Use enumeration of property names rather than iteration of keyset so that we make use of any default properties that might be set.
Revision 1.35 2007/06/19 11:33:35 billhorsman
Changed time (millisecond) properties from int to long: maximumConnectionLifetime, houseKeepingSleepTime, recentlyStartedThreshold, overloadWithoutRefusalLifetime, maximumActiveTime
Revision 1.34 2006/01/18 14:40:01 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.33 2005/05/04 16:24:59 billhorsman
Now supports cloning.
Revision 1.32 2004/06/02 20:19:14 billhorsman
Added injectable interface properties
Revision 1.31 2004/03/18 17:08:14 chr32
Added jmx* properties.
Revision 1.30 2004/03/15 02:42:44 chr32
Removed explicit JNDI properties. Going for a generic approach instead.
Revision 1.29 2003/10/30 00:13:59 billhorsman
Fixed bug where all proxool properties were getting passed onto the delegate driver, and all delegate properties weren't
Revision 1.28 2003/10/24 15:22:21 billhorsman
Fixed bug where connection pool was being recognised as changed even when it wasn't. (This bug introduced after 0.7.2).
Revision 1.27 2003/10/20 11:40:53 billhorsman
Smarter handling of null and empty strings. No NPE during unit tests now.
Revision 1.26 2003/10/19 13:31:57 billhorsman
Setting a property to a zero length String actually sets it to a null
Revision 1.25 2003/10/16 18:54:49 billhorsman
Fixed javadoc for update() and redefine() methods which were transposed. Also improved exception handling for
incomplete pool definitions.
Revision 1.24 2003/09/30 18:39:08 billhorsman
New test-before-use, test-after-use and fatal-sql-exception-wrapper-class properties.
Revision 1.23 2003/09/29 17:48:08 billhorsman
New fatal-sql-exception-wrapper-class allows you to define what exception is used as a wrapper. This means that you
can make it a RuntimeException if you need to.
Revision 1.22 2003/09/05 16:59:42 billhorsman
Added wrap-fatal-sql-exceptions property
Revision 1.21 2003/08/30 14:54:04 billhorsman
Checkstyle
Revision 1.20 2003/08/30 11:37:31 billhorsman
Trim fatal-sql-exception messages so that whitespace around the comma delimiters does not
get used to match against exception message.
Revision 1.19 2003/07/23 06:54:48 billhorsman
draft JNDI changes (shouldn't effect normal operation)
Revision 1.18 2003/04/27 15:42:21 billhorsman
fix to condition that meant configuration change was getting sent too often (and sometimes not at all)
Revision 1.17 2003/04/19 12:58:41 billhorsman
fixed bug where ConfigurationListener's
definitionUpdated was getting called too
frequently
Revision 1.16 2003/04/10 21:50:16 billhorsman
empty constructor for use by DataSource
Revision 1.15 2003/03/11 14:51:49 billhorsman
more concurrency fixes relating to snapshots
Revision 1.14 2003/03/10 23:43:09 billhorsman
reapplied checkstyle that i'd inadvertently let
IntelliJ change...
Revision 1.13 2003/03/10 15:26:45 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.12 2003/03/05 23:28:56 billhorsman
deprecated maximum-new-connections property in favour of
more descriptive simultaneous-build-throttle
Revision 1.11 2003/03/05 18:42:32 billhorsman
big refactor of prototyping and house keeping to
drastically reduce the number of threads when using
many pools
Revision 1.10 2003/03/03 11:11:57 billhorsman
fixed licence
Revision 1.9 2003/02/26 16:05:52 billhorsman
widespread changes caused by refactoring the way we
update and redefine pool definitions.
Revision 1.8 2003/02/06 15:41:17 billhorsman
add statistics-log-level
Revision 1.7 2003/01/31 00:17:05 billhorsman
statistics is now a string to allow multiple,
comma-delimited values
Revision 1.6 2003/01/30 17:20:38 billhorsman
new statistics property
Revision 1.5 2003/01/17 00:38:12 billhorsman
wide ranging changes to clarify use of alias and url -
this has led to some signature changes (new exceptions
thrown) on the ProxoolFacade API.
Revision 1.4 2002/11/09 15:50:15 billhorsman
new trace property and better doc
Revision 1.3 2002/10/27 13:29:38 billhorsman
deprecated debug-level in favour of verbose
Revision 1.2 2002/10/17 19:46:02 billhorsman
removed redundant reference to logFilename (we now use Jakarta's Commons Logging component
Revision 1.1.1.1 2002/09/13 08:13:00 billhorsman
new
Revision 1.8 2002/07/10 16:14:47 billhorsman
widespread layout changes and move constants into ProxoolConstants
Revision 1.7 2002/07/04 09:05:36 billhorsman
Fixes
Revision 1.6 2002/07/02 11:19:08 billhorsman
layout code and imports
Revision 1.5 2002/07/02 08:41:59 billhorsman
No longer public - we should be confuring pools with Properties now. Also added completeUrl property so that we can access pool by either alias or full url.
Revision 1.4 2002/06/28 11:19:47 billhorsman
improved doc
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ConnectionPoolDefinitionIF.java 0000644 0001750 0001750 00000035630 10730503125 032535 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import java.util.Properties;
import java.util.Set;
/**
* A full definition of everything to do with a connection. You can get one of these
* from {@link ProxoolFacade#getConnectionPoolDefinition ProxoolFacade}.
*
* * String alias = "myPool"; * ConnectionPoolDefinitionIF cpd = ProxoolFacade.getConnectionPoolDefinition(alias); ** * If you want to update the definition you should either update the properties * definition next time you * {@link java.sql.Driver#connect ask} for a connection or call * {@link ProxoolFacade#updateConnectionPool Proxool} directly. * * @version $Revision: 1.23 $, $Date: 2007/06/19 11:33:35 $ * @author billhorsman * @author $Author: billhorsman $ (current maintainer) */ public interface ConnectionPoolDefinitionIF { /** 4 * 60 * 60 * 1000 (4 hours) */ public static final int DEFAULT_MAXIMUM_CONNECTION_LIFETIME = 4 * 60 * 60 * 1000; // 4 hours /** 300000 (5 minutes) */ public static final int DEFAULT_MAXIMUM_ACTIVE_TIME = 300000; // 5 minutes /** 0 */ public static final int DEFAULT_PROTOTYPE_COUNT = 0; /** 0 */ public static final int DEFAULT_MINIMUM_CONNECTION_COUNT = 0; /** 15 */ public static final int DEFAULT_MAXIMUM_CONNECTION_COUNT = 15; /** 30000 (30 Seconds) */ public static final int DEFAULT_HOUSE_KEEPING_SLEEP_TIME = 30000; /** 10 * @deprecated use {@link #DEFAULT_SIMULTANEOUS_BUILD_THROTTLE} instead */ public static final int DEFAULT_MAXIMUM_NEW_CONNECTIONS = 10; /** 10 */ public static final int DEFAULT_SIMULTANEOUS_BUILD_THROTTLE = 10; /** 60000 */ public static final int DEFAULT_OVERLOAD_WITHOUT_REFUSAL_THRESHOLD = 60000; /** 60000 */ public static final int DEFAULT_RECENTLY_STARTED_THRESHOLD = 60000; public static final int DEBUG_LEVEL_QUIET = 0; public static final int DEBUG_LEVEL_LOUD = 1; public static final String USER_PROPERTY = "user"; public static final String PASSWORD_PROPERTY = "password"; /** * @see #getFatalSqlExceptions */ public static final String FATAL_SQL_EXCEPTIONS_DELIMITER = ","; /** This is the time the house keeping thread sleeps for between checks. (milliseconds) */ long getHouseKeepingSleepTime(); /** The maximum number of connections to the database */ int getMaximumConnectionCount(); /** The maximum amount of time that a connection exists for before it is killed (recycled). (milliseconds) */ long getMaximumConnectionLifetime(); /** * In order to prevent overloading, this is the maximum number of connections that you can have that are in the progress * of being made. That is, ones we have started to make but haven't finished yet. * @deprecated use more descriptive {@link #getSimultaneousBuildThrottle} instead */ int getMaximumNewConnections(); /** * In order to prevent overloading, this is the maximum number of connections that you can have that are in the progress * of being made. That is, ones we have started to make but haven't finished yet. */ int getSimultaneousBuildThrottle(); /** The minimum number of connections we will keep open, regardless of whether anyone needs them or not. */ int getMinimumConnectionCount(); /** @deprecated use {@link #getAlias} instead. */ String getName(); /** The name associated with this connection pool. This is how you identify this pool when you need to use it. */ String getAlias(); /** The password to use to login to the database */ String getPassword(); /** * This is the number of spare connections we will strive to have. So, if we have a prototypeCount of 5 but only 3 spare * connections the prototyper will make an additional 2. This is important because it can take around a seconds to * establish a connection, and if we are being very strict about killing connections when they get too * old it happens a fair bit. */ int getPrototypeCount(); /** This is the URL used to connect to the database. e.g. driver:@host:port:database. */ String getUrl(); /* The user used to login to the database. */ String getUser(); /* Interrogate the JDBC driver for its version (warning: this information is not always correct - be very suspicious if it reports the version as 1.0) */ String getJdbcDriverVersion(); /** * Get all of the properties that are defined on the delegated driver. * @return the delegate properties * @deprecated use less ambiguous {@link #getDelegateProperties} instead */ Properties getProperties(); String getDriver(); /** As long as we have one connection that was started within this threshold then we consider the pool to be up. (That is, not down). This allows us to differentiate between having all the connections frozen and just being really busy. */ long getRecentlyStartedThreshold(); /** This is the time in milliseconds after the last time that we refused a connection that we still consider ourselves to be overloaded. We have to do this because, even when overloaded, it's not impossible for the available connection count to be high and it's possible to be serving a lot of connections. Recognising an overload is easy (we refuse a connection) - it's recognising when we stop being overloaded that is hard. Hence this fudge :) */ long getOverloadWithoutRefusalLifetime(); /** If the housekeeper comes across a thread that has been active for longer than this then it will kill it. So make sure you set this to a number bigger than your slowest expected response! */ long getMaximumActiveTime(); /** * @deprecated use {@link #isVerbose} instead */ int getDebugLevel(); /** * Get the list of fatal SQL exception (Strings) fragments that will * trigger the death of a Connection. * All SQLExceptions are caught and tested for containing this * text fragment. If it matches than this connection is considered useless * and it is discarded. Regardless of what happens the exception * is always thrown back to the user. * @return the list of exception fragments (String) * @see #FATAL_SQL_EXCEPTIONS_DELIMITER */ Set getFatalSqlExceptions(); /** * The test SQL that we perform to see if a connection is alright. * Should be fast and robust. * @return house keeping test SQL */ String getHouseKeepingTestSql(); /** * Whether we test each connection before it is served * @return true if we do the test * @see #getHouseKeepingTestSql */ boolean isTestBeforeUse(); /** * Whether we test each connection after it is closed * (that is, returned to the pool) * @return true if we do the test * @see #getHouseKeepingTestSql */ boolean isTestAfterUse(); /** * The URL that was used to define this pool. For example: * proxool:org.hsqldb.jdbcDriver:jdbc:hsqldb:test * @return the complete url */ String getCompleteUrl(); /** * If this is true then we start logging a lot of stuff everytime we serve a * connection and everytime the house keeper and prototyper run. Be * prepared for a lot of debug! * * @return true if in verbose mode */ boolean isVerbose(); /** * if this is true then we will log each execution. The SQL used and the * execution time. * * @return true if we should log each execution */ boolean isTrace(); /** * The sample length (in seconds) when taking statistical information, * or null to disable statistics. Default is null. You can comma delimit * a series of periods. The suffix for the period is either "s" (seconds), * "m" (minutes), "h" (hours) or "d" (days). For example: "15s,1h" would * give two separate sample rates: every 15 seconds and every hour. * @return statistics definition */ String getStatistics(); /** * Whether statistics are logged as they are produced. * Range: DEBUG, INFO, WARN, ERROR, FATAL. * Default is null (no logging) * @return statisticsLogLevel */ String getStatisticsLogLevel(); /** * Get all of the properties that are defined on the delegated driver. * @return the delegate properties */ Properties getDelegateProperties(); String getDelegateProperty(String name); /** * If this is not-null then any fatal SQLException is wrapped up inside * an instance of this class. If null, then the original exception is * thrown. * Range: any valid class name that is a subclass of SQLException or RuntimeException * Default: null (original exception is thrown) * @return the class name to use for fatal SQL exceptions */ String getFatalSqlExceptionWrapper(); /** * JNDI property * @return the initial context factory */ String getInitialContextFactory(); /** * JNDI property * @return provider URL */ String getProviderUrl(); /** * JNDI property * @return security authentication */ String getSecurityAuthentication(); /** * JNDI property * @return security principal */ String getSecurityPrincipal(); /** * JNDI property * @return security credentials */ String getSecurityCredentials(); /** * JNDI property * @return JNDI name */ String getJndiName(); /** * Indicate wether this pool should be registered with JMX or not. * @return wether this pool should be registered with JMX or not. */ boolean isJmx(); /** * Get a comma separated list of JMX agent ids (as used by *
MBeanServerFactory.findMBeanServer(String agentId)) to register the pool to.
* @return a comma separated list of JMX agent ids (as used by
* MBeanServerFactory.findMBeanServer(String agentId)) to register the pool to.
*/
String getJmxAgentId();
/**
* The class name of an interface that should be injected everytime we make a Connection.
* Use this when you want to access methods on a concrete class in the vendor's Connection
* object that aren't declared in a public interface. Without this, the connection that
* gets served will only give you access to public interfaces (like Connection and any
* other vendor provided ones)
* @return the interface
*/
Class getInjectableConnectionInterface();
/**
* The class name of an interface that should be injected everytime we make a Statement.
* Use this when you want to access methods on a concrete class in the vendor's Statement
* object that aren't declared in a public interface. Without this, the statement that
* is provided will only give you access to public interfaces (like Statement and any
* other vendor provided ones)
* @return the interface
*/
Class getInjectableStatementInterface();
/**
* The class name of an interface that should be injected everytime we make a PreparedStatement.
* Use this when you want to access methods on a concrete class in the vendor's PreparedStatement
* object that aren't declared in a public interface. Without this, the PreparedStatement that
* is provided will only give you access to public interfaces (like PreparedStatement and any
* other vendor provided ones)
* @return the interface
*/
Class getInjectablePreparedStatementInterface();
/**
* The class name of an interface that should be injected everytime we make a CallableStatement.
* Use this when you want to access methods on a concrete class in the vendor's CallableStatement
* object that aren't declared in a public interface. Without this, the CallableStatement that
* is provided will only give you access to public interfaces (like CallableStatement and any
* other vendor provided ones)
* @return the interface
*/
Class getInjectableCallableStatementInterface();
}
/*
Revision history:
$Log: ConnectionPoolDefinitionIF.java,v $
Revision 1.23 2007/06/19 11:33:35 billhorsman
Changed time (millisecond) properties from int to long: maximumConnectionLifetime, houseKeepingSleepTime, recentlyStartedThreshold, overloadWithoutRefusalLifetime, maximumActiveTime
Revision 1.22 2004/06/02 20:19:14 billhorsman
Added injectable interface properties
Revision 1.21 2004/03/18 17:08:14 chr32
Added jmx* properties.
Revision 1.20 2003/09/30 18:39:08 billhorsman
New test-before-use, test-after-use and fatal-sql-exception-wrapper-class properties.
Revision 1.19 2003/09/29 17:48:08 billhorsman
New fatal-sql-exception-wrapper-class allows you to define what exception is used as a wrapper. This means that you
can make it a RuntimeException if you need to.
Revision 1.18 2003/09/05 16:59:42 billhorsman
Added wrap-fatal-sql-exceptions property
Revision 1.17 2003/07/23 06:54:48 billhorsman
draft JNDI changes (shouldn't effect normal operation)
Revision 1.16 2003/03/05 23:28:56 billhorsman
deprecated maximum-new-connections property in favour of
more descriptive simultaneous-build-throttle
Revision 1.15 2003/03/03 11:11:57 billhorsman
fixed licence
Revision 1.14 2003/02/26 16:05:52 billhorsman
widespread changes caused by refactoring the way we
update and redefine pool definitions.
Revision 1.13 2003/02/06 15:41:17 billhorsman
add statistics-log-level
Revision 1.12 2003/01/31 00:17:04 billhorsman
statistics is now a string to allow multiple,
comma-delimited values
Revision 1.11 2003/01/30 17:20:37 billhorsman
new statistics property
Revision 1.10 2003/01/17 00:38:12 billhorsman
wide ranging changes to clarify use of alias and url -
this has led to some signature changes (new exceptions
thrown) on the ProxoolFacade API.
Revision 1.9 2002/12/17 14:20:44 billhorsman
doc
Revision 1.8 2002/12/15 19:21:42 chr32
Changed @linkplain to @link (to preserve JavaDoc for 1.2/1.3 users).
Revision 1.7 2002/11/09 15:50:15 billhorsman
new trace property and better doc
Revision 1.6 2002/10/27 13:29:38 billhorsman
deprecated debug-level in favour of verbose
Revision 1.5 2002/10/27 12:09:00 billhorsman
default minimum connection count changed from 5 to 0
Revision 1.4 2002/10/25 16:00:25 billhorsman
added better class javadoc
Revision 1.3 2002/10/24 17:29:06 billhorsman
prototype count now defaults to zero
Revision 1.2 2002/10/17 19:46:02 billhorsman
removed redundant reference to logFilename (we now use Jakarta's Commons Logging component
Revision 1.1.1.1 2002/09/13 08:13:02 billhorsman
new
Revision 1.6 2002/07/02 08:44:56 billhorsman
Removed all mutators
Revision 1.5 2002/06/28 11:19:47 billhorsman
improved doc
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ConnectionPoolManager.java 0000644 0001750 0001750 00000014020 10730503124 031565 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
*
* @version $Revision: 1.16 $, $Date: 2006/01/18 14:40:01 $
* @author billhorsman
* @author $Author: billhorsman $ (current maintainer)
*/
class ConnectionPoolManager {
private static final Object LOCK = new Object();
private Map connectionPoolMap = new HashMap();
private Set connectionPools = new HashSet();
private static ConnectionPoolManager connectionPoolManager = null;
private static final Log LOG = LogFactory.getLog(ProxoolFacade.class);
public static ConnectionPoolManager getInstance() {
if (connectionPoolManager == null) {
synchronized (LOCK) {
if (connectionPoolManager == null) {
connectionPoolManager = new ConnectionPoolManager();
}
}
}
return connectionPoolManager;
}
private ConnectionPoolManager() {
}
/**
* Get the pool by the alias
* @param alias identifies the pool
* @return the pool
* @throws ProxoolException if it couldn't be found
*/
protected ConnectionPool getConnectionPool(String alias) throws ProxoolException {
ConnectionPool cp = (ConnectionPool) connectionPoolMap.get(alias);
if (cp == null) {
throw new ProxoolException(getKnownPools(alias));
}
return cp;
}
/**
* Convenient method for outputing a message explaining that a pool couldn't
* be found and listing the ones that could be found.
* @param alias identifies the pool
* @return a description of the wht the pool couldn't be found
*/
protected String getKnownPools(String alias) {
StringBuffer message = new StringBuffer("Couldn't find a pool called '" + alias + "'. Known pools are: ");
Iterator i = connectionPoolMap.keySet().iterator();
while (i.hasNext()) {
message.append((String) i.next());
message.append(i.hasNext() ? ", " : ".");
}
return message.toString();
}
/**
* Whether the pool is already registered
* @param alias how we identify the pool
* @return true if it already exists, else false
*/
protected boolean isPoolExists(String alias) {
return connectionPoolMap.containsKey(alias);
}
/** @return an array of the connection pools */
protected ConnectionPool[] getConnectionPools() {
return (ConnectionPool[]) connectionPools.toArray(new ConnectionPool[connectionPools.size()]);
}
protected ConnectionPool createConnectionPool(ConnectionPoolDefinition connectionPoolDefinition) throws ProxoolException {
ConnectionPool connectionPool = new ConnectionPool(connectionPoolDefinition);
connectionPools.add(connectionPool);
connectionPoolMap.put(connectionPoolDefinition.getAlias(), connectionPool);
return connectionPool;
}
protected void removeConnectionPool(String name) {
ConnectionPool cp = (ConnectionPool) connectionPoolMap.get(name);
if (cp != null) {
connectionPoolMap.remove(cp.getDefinition().getAlias());
connectionPools.remove(cp);
} else {
LOG.info("Ignored attempt to remove either non-existent or already removed connection pool " + name);
}
}
public String[] getConnectionPoolNames() {
return (String[]) connectionPoolMap.keySet().toArray(new String[connectionPoolMap.size()]);
}
}
/*
Revision history:
$Log: ConnectionPoolManager.java,v $
Revision 1.16 2006/01/18 14:40:01 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.15 2003/03/11 14:51:51 billhorsman
more concurrency fixes relating to snapshots
Revision 1.14 2003/03/10 23:43:09 billhorsman
reapplied checkstyle that i'd inadvertently let
IntelliJ change...
Revision 1.13 2003/03/10 15:26:45 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.12 2003/03/03 11:11:57 billhorsman
fixed licence
Revision 1.11 2003/03/01 15:27:24 billhorsman
checkstyle
Revision 1.10 2003/02/28 10:42:59 billhorsman
ConnectionPoolManager now passes ProxoolFacade an
array of ConnectionPools rather than a Collection
to avoid a ConcurrentModificationException during
shutdown.
Revision 1.9 2003/02/07 10:27:47 billhorsman
change in shutdown procedure to allow re-registration
Revision 1.8 2003/02/06 17:41:04 billhorsman
now uses imported logging
Revision 1.7 2003/01/27 18:26:36 billhorsman
refactoring of ProxyConnection and ProxyStatement to
make it easier to write JDK 1.2 patch
Revision 1.6 2003/01/23 11:08:26 billhorsman
new setConfiguratorListener method (and remove from optional
parameter when registering pool)
Revision 1.5 2003/01/17 00:38:12 billhorsman
wide ranging changes to clarify use of alias and url -
this has led to some signature changes (new exceptions
thrown) on the ProxoolFacade API.
Revision 1.4 2002/12/15 19:21:42 chr32
Changed @linkplain to @link (to preserve JavaDoc for 1.2/1.3 users).
Revision 1.3 2002/11/09 15:49:36 billhorsman
add method to get the name of every pool
Revision 1.2 2002/10/13 13:39:03 billhorsman
fix when removing pools (credit to Dan Milstein)
Revision 1.1.1.1 2002/09/13 08:13:04 billhorsman
new
Revision 1.8 2002/07/10 16:14:47 billhorsman
widespread layout changes and move constants into ProxoolConstants
Revision 1.7 2002/07/04 09:05:36 billhorsman
Fixes
Revision 1.6 2002/07/02 11:19:08 billhorsman
layout code and imports
Revision 1.5 2002/07/02 08:47:31 billhorsman
you can now access a pool by alias or full url
Revision 1.4 2002/06/28 11:19:47 billhorsman
improved doc
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ConnectionPoolStatisticsIF.java 0000644 0001750 0001750 00000005205 10730503125 032572 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import java.util.Date;
/**
* This provides real time information about the pool. You can get this from
* {@link ProxoolFacade#getConnectionPoolStatistics ProxoolFacade}.
*
* * String alias = "myPool"; * ConnectionPoolStatisticsIF cps = ProxoolFacade.getConnectionPoolStatistics(alias); ** * @version $Revision: 1.6 $, $Date: 2005/10/02 12:32:02 $ * @author billhorsman * @author $Author: billhorsman $ (current maintainer) */ public interface ConnectionPoolStatisticsIF { /** * The number of connections provided. * @return connectionsServedCount */ long getConnectionsServedCount(); /** * The number of connections refused. Either because there was a problem * connecting to the database, or perhaps because the maximumConnectionCount * was reached. * @return connectionsRefusedCount */ long getConnectionsRefusedCount(); /** * The number of connections currently in use. * @return activeConnectionCount */ int getActiveConnectionCount(); /** * The number of connections that are available for use (doesn't include * active connections). * @return availableConnectionCount */ int getAvailableConnectionCount(); /** * The number of connections that are neither active or available. Probably * because the house keeping thread is checking them. * @return offlineConnectionCount */ int getOfflineConnectionCount(); /** * When this pool was started * @return dateStarted */ Date getDateStarted(); long getConnectionCount(); } /* Revision history: $Log: ConnectionPoolStatisticsIF.java,v $ Revision 1.6 2005/10/02 12:32:02 billhorsman Make connectionCount available to statistics Revision 1.5 2003/03/03 11:11:57 billhorsman fixed licence Revision 1.4 2003/01/15 12:01:21 billhorsman added getDateStarted() plus better doc Revision 1.3 2002/12/15 19:21:42 chr32 Changed @linkplain to @link (to preserve JavaDoc for 1.2/1.3 users). Revision 1.2 2002/10/25 16:00:26 billhorsman added better class javadoc Revision 1.1.1.1 2002/09/13 08:13:04 billhorsman new Revision 1.6 2002/07/10 16:14:47 billhorsman widespread layout changes and move constants into ProxoolConstants Revision 1.5 2002/07/02 11:19:08 billhorsman layout code and imports Revision 1.4 2002/06/28 11:19:47 billhorsman improved doc */ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ConnectionResetter.java 0000644 0001750 0001750 00000036631 10730503124 031172 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool; import org.apache.commons.logging.Log; import org.apache.commons.logging.Log; import java.lang.reflect.Method; import java.sql.Connection; import java.sql.SQLException; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.Map; import java.util.Set; /** * Responsible for resetting a Connection to its default state when it is * returned to the pool. It must be initialised by the first Connection that * is made (for each pool) so that we don't make any assumptions about * what the default values are. * * @version $Revision: 1.16 $, $Date: 2006/01/18 14:40:01 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ public class ConnectionResetter { private Log log; /** * @see #initialise */ private boolean initialised; /** * @see #addReset * @see #reset */ private Map accessorMutatorMap = new HashMap(); /** * @see #addReset * @see #reset */ private Map defaultValues = new HashMap(); /** * We use this to guess if we are changing a property that will need resetting */ protected static final String MUTATOR_PREFIX = "set"; private String driverName; /** * @see #isTriggerResetException() */ protected static boolean triggerResetException; /** * Pass in the log to use * @param log debug information sent here */ protected ConnectionResetter(Log log, String driverName) { this.log = log; this.driverName = driverName; // Map all the reset methods addReset("getCatalog", "setCatalog"); addReset("isReadOnly", "setReadOnly"); addReset("getTransactionIsolation", "setTransactionIsolation"); addReset("getTypeMap", "setTypeMap"); addReset("getHoldability", "setHoldability"); } /** * Add a pair of methods that need resetting each time a connection is * put back in the pool * @param accessorName the name of the "getter" method (e.g. getAutoCommit) * @param mutatorName teh name of the "setter" method (e.g. setAutoCommit) */ private void addReset(String accessorName, String mutatorName) { try { Method accessor = null; Method mutator = null; Method[] methods = Connection.class.getMethods(); for (int i = 0; i < methods.length; i++) { Method method = methods[i]; if (method.getName().equals(accessorName)) { if (accessor == null) { accessor = method; } else { log.info("Skipping ambiguous reset method " + accessorName); return; } } if (method.getName().equals(mutatorName)) { if (mutator == null) { mutator = method; } else { log.info("Skipping ambiguous reset method " + mutatorName); return; } } } if (accessor == null) { log.debug("Ignoring attempt to map reset method " + accessorName + " (probably because it isn't implemented in this JDK)"); } else if (mutator == null) { log.debug("Ignoring attempt to map reset method " + mutatorName + " (probably because it isn't implemented in this JDK)"); } else if (accessorMutatorMap.containsKey(accessor)) { log.warn("Ignoring attempt to map duplicate reset method " + accessorName); } else if (accessorMutatorMap.containsValue(mutator)) { log.warn("Ignoring attempt to map duplicate reset method " + mutatorName); } else { if (mutatorName.indexOf(MUTATOR_PREFIX) != 0) { log.warn("Resetter mutator " + mutatorName + " does not start with " + MUTATOR_PREFIX + " as expected. Proxool maynot recognise that a reset is necessary."); } if (accessor.getParameterTypes().length > 0) { log.info("Ignoring attempt to map accessor method " + accessorName + ". It must have no arguments."); } else if (mutator.getParameterTypes().length != 1) { log.info("Ignoring attempt to map mutator method " + mutatorName + ". It must have exactly one argument, not " + mutator.getParameterTypes().length); } else { accessorMutatorMap.put(accessor, mutator); } } } catch (Exception e) { log.error("Problem mapping " + accessorName + " and " + mutatorName, e); } } /** * This gets called every time we make a Connection. Not that often * really, so it's ok to synchronize a bit. * @param connection this will be used to get all the default values */ protected void initialise(Connection connection) { if (!initialised) { synchronized (this) { if (!initialised) { Set accessorsToRemove = new HashSet(); Iterator i = accessorMutatorMap.keySet().iterator(); while (i.hasNext()) { Method accessor = (Method) i.next(); Method mutator = (Method) accessorMutatorMap.get(accessor); Object value = null; try { value = accessor.invoke(connection, null); // It's perfectly ok for the default value to be null, we just // don't want to add it to the map. if (value != null) { defaultValues.put(mutator, value); } if (log.isDebugEnabled()) { log.debug("Remembering default value: " + accessor.getName() + "() = " + value); } } catch (Throwable t) { log.debug(driverName + " does not support " + accessor.getName() + ". Proxool doesn't mind."); // We will remove this later (to avoid ConcurrentModifcation) accessorsToRemove.add(accessor); } // Just test that the mutator works too. Otherwise it's going to fall over // everytime we close a connection try { Object[] args = {value}; mutator.invoke(connection, args); } catch (Throwable t) { log.debug(driverName + " does not support " + mutator.getName() + ". Proxool doesn't mind."); // We will remove this later (to avoid ConcurrentModifcation) accessorsToRemove.add(accessor); } } // Remove all the reset methods that we had trouble configuring Iterator j = accessorsToRemove.iterator(); while (j.hasNext()) { Method accessor = (Method) j.next(); Method mutator = (Method) accessorMutatorMap.get(accessor); accessorMutatorMap.remove(accessor); defaultValues.remove(mutator); } initialised = true; } } } } /** * Reset this connection to its default values. If anything goes wrong, it is logged * as a warning or info but it silently continues. * @param connection to be reset * @param id used in log messages * @return true if the reset was error free, or false if it encountered errors. (in which case it should probably not be reused) */ protected boolean reset(Connection connection, String id) { boolean errorsEncountered = false; try { connection.clearWarnings(); } catch (SQLException e) { errorsEncountered = true; log.warn(id + " - Problem calling connection.clearWarnings()", e); } // Let's see the state of autoCommit. It will help us give better advice in the log messages boolean autoCommit = true; try { autoCommit = connection.getAutoCommit(); } catch (SQLException e) { errorsEncountered = true; log.warn(id + " - Problem calling connection.getAutoCommit()", e); } /* Automatically rollback if autocommit is off. If there are no pending transactions then this will have no effect. From Database Language SQL (Proposed revised text of DIS 9075), July 1992 - http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt "The execution of a
foo=1,bar=true
* @param properties a comma delimited list of name=value pairs
* @see ConnectionPoolDefinitionIF#getDelegateProperties()
*/
public void setDelegateProperties(String properties) {
StringTokenizer stOuter = new StringTokenizer(properties, ",");
while (stOuter.hasMoreTokens()) {
StringTokenizer stInner = new StringTokenizer(stOuter.nextToken(), "=");
if (stInner.countTokens() == 1) {
// Allow blank string to be a valid value
delegateProperties.put(stInner.nextToken().trim(), "");
} else if (stInner.countTokens() == 2) {
delegateProperties.put(stInner.nextToken().trim(), stInner.nextToken().trim());
} else {
throw new IllegalArgumentException("Unexpected delegateProperties value: '" + properties + "'. Expected 'name=value'");
}
}
}
private void populatePropertiesFromReference(Reference reference) {
RefAddr property = reference.get(ProxoolConstants.ALIAS_PROPERTY);
if (property != null) {
setAlias(property.getContent().toString());
}
property = reference.get(ProxoolConstants.DRIVER_CLASS_PROPERTY);
if (property != null) {
setDriver(property.getContent().toString());
}
property = reference.get(ProxoolConstants.FATAL_SQL_EXCEPTION_WRAPPER_CLASS_PROPERTY);
if (property != null) {
setFatalSqlExceptionWrapperClass(property.getContent().toString());
}
property = reference.get(ProxoolConstants.HOUSE_KEEPING_SLEEP_TIME_PROPERTY);
if (property != null) {
setHouseKeepingSleepTime(Integer.valueOf(property.getContent().toString()).intValue());
}
property = reference.get(ProxoolConstants.HOUSE_KEEPING_TEST_SQL_PROPERTY);
if (property != null) {
setHouseKeepingTestSql(property.getContent().toString());
}
property = reference.get(ProxoolConstants.MAXIMUM_CONNECTION_COUNT_PROPERTY);
if (property != null) {
setMaximumConnectionCount(Integer.valueOf(property.getContent().toString()).intValue());
}
property = reference.get(ProxoolConstants.MAXIMUM_CONNECTION_LIFETIME_PROPERTY);
if (property != null) {
setMaximumConnectionLifetime(Integer.valueOf(property.getContent().toString()).intValue());
}
property = reference.get(ProxoolConstants.MAXIMUM_ACTIVE_TIME_PROPERTY);
if (property != null) {
setMaximumActiveTime(Long.valueOf(property.getContent().toString()).intValue());
}
property = reference.get(ProxoolConstants.MINIMUM_CONNECTION_COUNT_PROPERTY);
if (property != null) {
setMinimumConnectionCount(Integer.valueOf(property.getContent().toString()).intValue());
}
property = reference.get(ProxoolConstants.OVERLOAD_WITHOUT_REFUSAL_LIFETIME_PROPERTY);
if (property != null) {
setOverloadWithoutRefusalLifetime(Integer.valueOf(property.getContent().toString()).intValue());
}
property = reference.get(ProxoolConstants.PASSWORD_PROPERTY);
if (property != null) {
setPassword(property.getContent().toString());
}
property = reference.get(ProxoolConstants.PROTOTYPE_COUNT_PROPERTY);
if (property != null) {
setPrototypeCount(Integer.valueOf(property.getContent().toString()).intValue());
}
property = reference.get(ProxoolConstants.RECENTLY_STARTED_THRESHOLD_PROPERTY);
if (property != null) {
setRecentlyStartedThreshold(Integer.valueOf(property.getContent().toString()).intValue());
}
property = reference.get(ProxoolConstants.SIMULTANEOUS_BUILD_THROTTLE_PROPERTY);
if (property != null) {
setSimultaneousBuildThrottle(Integer.valueOf(property.getContent().toString()).intValue());
}
property = reference.get(ProxoolConstants.STATISTICS_PROPERTY);
if (property != null) {
setStatistics(property.getContent().toString());
}
property = reference.get(ProxoolConstants.STATISTICS_LOG_LEVEL_PROPERTY);
if (property != null) {
setStatisticsLogLevel(property.getContent().toString());
}
property = reference.get(ProxoolConstants.TRACE_PROPERTY);
if (property != null) {
setTrace("true".equalsIgnoreCase(property.getContent().toString()));
}
property = reference.get(ProxoolConstants.DRIVER_URL_PROPERTY);
if (property != null) {
setDriverUrl(property.getContent().toString());
}
property = reference.get(ProxoolConstants.USER_PROPERTY);
if (property != null) {
setUser(property.getContent().toString());
}
property = reference.get(ProxoolConstants.VERBOSE_PROPERTY);
if (property != null) {
setVerbose("true".equalsIgnoreCase(property.getContent().toString()));
}
property = reference.get(ProxoolConstants.JMX_PROPERTY);
if (property != null) {
setJmx("true".equalsIgnoreCase(property.getContent().toString()));
}
property = reference.get(ProxoolConstants.JMX_AGENT_PROPERTY);
if (property != null) {
setJmxAgentId(property.getContent().toString());
}
property = reference.get(ProxoolConstants.TEST_BEFORE_USE_PROPERTY);
if (property != null) {
setTestBeforeUse("true".equalsIgnoreCase(property.getContent().toString()));
}
property = reference.get(ProxoolConstants.TEST_AFTER_USE_PROPERTY);
if (property != null) {
setTestAfterUse("true".equalsIgnoreCase(property.getContent().toString()));
}
// Pick up any properties that we don't recognise
Enumeration e = reference.getAll();
while (e.hasMoreElements()) {
StringRefAddr stringRefAddr = (StringRefAddr) e.nextElement();
String name = stringRefAddr.getType();
String content = stringRefAddr.getContent().toString();
if (name.indexOf(ProxoolConstants.PROPERTY_PREFIX) != 0) {
delegateProperties.put(name, content);
}
}
}
/**
* Reset all properties to their default values
*/
private void reset() {
driverUrl = null;
driver = null;
maximumConnectionLifetime = ConnectionPoolDefinitionIF.DEFAULT_MAXIMUM_CONNECTION_LIFETIME;
prototypeCount = ConnectionPoolDefinitionIF.DEFAULT_PROTOTYPE_COUNT;
minimumConnectionCount = ConnectionPoolDefinitionIF.DEFAULT_MINIMUM_CONNECTION_COUNT;
maximumConnectionCount = ConnectionPoolDefinitionIF.DEFAULT_MAXIMUM_CONNECTION_COUNT;
houseKeepingSleepTime = ConnectionPoolDefinitionIF.DEFAULT_HOUSE_KEEPING_SLEEP_TIME;
houseKeepingTestSql = null;
simultaneousBuildThrottle = ConnectionPoolDefinitionIF.DEFAULT_SIMULTANEOUS_BUILD_THROTTLE;
recentlyStartedThreshold = ConnectionPoolDefinitionIF.DEFAULT_RECENTLY_STARTED_THRESHOLD;
overloadWithoutRefusalLifetime = ConnectionPoolDefinitionIF.DEFAULT_OVERLOAD_WITHOUT_REFUSAL_THRESHOLD;
maximumActiveTime = ConnectionPoolDefinitionIF.DEFAULT_MAXIMUM_ACTIVE_TIME;
verbose = false;
trace = false;
statistics = null;
statisticsLogLevel = null;
delegateProperties.clear();
}
public PrintWriter getLogWriter() throws SQLException {
return this.logWriter;
}
public int getLoginTimeout() throws SQLException {
return this.loginTimeout;
}
public void setLogWriter(PrintWriter logWriter) throws SQLException {
this.logWriter = logWriter;
}
public void setLoginTimeout(int loginTimeout) throws SQLException {
this.loginTimeout = loginTimeout;
}
public Connection getConnection(String s, String s1) throws SQLException {
throw new UnsupportedOperationException("You should configure the username and password "
+ "within the proxool configuration and just call getConnection() instead.");
}
}
/*
Revision history:
$Log: ProxoolDataSource.java,v $
Revision 1.11 2007/12/14 23:03:28 billhorsman
Use long consistently for maximum_active_time, not int.
Revision 1.10 2007/12/14 13:49:39 billhorsman
Allow a blank string to be a valid value for a delegate property
Revision 1.9 2007/06/19 11:33:35 billhorsman
Changed time (millisecond) properties from int to long: maximumConnectionLifetime, houseKeepingSleepTime, recentlyStartedThreshold, overloadWithoutRefusalLifetime, maximumActiveTime
Revision 1.8 2007/05/15 23:10:15 billhorsman
We must setUser and setPassword *after* setDelegateProperties otherwise the values will be overwritten. Credit Bulent Erdemir (bug 1716955)
Revision 1.7 2006/05/23 21:17:55 billhorsman
Add in maximum-active-time. Credit to Paolo Di Tommaso.
Revision 1.6 2006/03/23 11:51:23 billhorsman
Allow for delegate properties
Revision 1.5 2006/01/18 14:40:01 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.4 2004/08/19 12:28:28 chr32
Removed factory type test.
Revision 1.3 2004/03/18 17:16:58 chr32
Added a timy bit of doc.
Revision 1.2 2004/03/18 17:07:25 chr32
Now supports all three modes: pre-configured, bean-configured and factory-configured.
Revision 1.1 2004/03/15 23:54:25 chr32
Initail Proxool J2EE-managed DataSource. Not quite complete yet.
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ProxoolDriver.java 0000644 0001750 0001750 00000027510 10730503125 030170 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.resources.ResourceNamesIF;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.SQLException;
import java.util.Properties;
import java.util.ResourceBundle;
/**
* This is the Proxool implementation of the java.sql.Driver interface.
* @version $Revision: 1.28 $, $Date: 2006/01/18 14:40:01 $
* @author billhorsman
* @author $Author: billhorsman $ (current maintainer)
*/
public class ProxoolDriver implements Driver {
private static final Log LOG = LogFactory.getLog(ProxoolDriver.class);
static {
try {
DriverManager.registerDriver(new ProxoolDriver());
} catch (SQLException e) {
System.out.println(e.toString());
}
}
private static final ResourceBundle ATTRIBUTE_DESCRIPTIONS_RESOURCE = createAttributeDescriptionsResource ();
private static ResourceBundle createAttributeDescriptionsResource () {
try {
return ResourceBundle.getBundle (ResourceNamesIF.ATTRIBUTE_DESCRIPTIONS);
} catch (Exception e) {
LOG.error ("Could not find resource " + ResourceNamesIF.ATTRIBUTE_DESCRIPTIONS, e);
}
return null;
}
/**
* The url should be of the form:
*
* proxool:delegate-class:delegate-url
*
* or,
*
* proxool.name:delegate-class:delegate-url
*
* where delegate-classis the actual Driver that will be used and *
delegate-urlis the url that will be based to that Driver * * By defining
nameyou are able to define multiple connection pools * even if the delegate url is the same. The entire url (including the proxool.name) is * used to uniquely identify this pool. * */ public Connection connect(String url, Properties info) throws SQLException { if (!url.startsWith("proxool")) { return null; } ConnectionPool cp = null; try { String alias = ProxoolFacade.getAlias(url); if (!ConnectionPoolManager.getInstance().isPoolExists(alias)) { ProxoolFacade.registerConnectionPool(url, info, false); cp = ConnectionPoolManager.getInstance().getConnectionPool(alias); } else if (info != null && info.size() > 0) { // Perhaps we should be redefining the definition? cp = ConnectionPoolManager.getInstance().getConnectionPool(alias); ConnectionPoolDefinition cpd = cp.getDefinition(); if (!cpd.isEqual(url, info)) { cpd.redefine(url, info); } } else { cp = ConnectionPoolManager.getInstance().getConnectionPool(alias); } return cp.getConnection(); } catch (SQLException e) { // We don't log exceptions. Leave that up to the client. // LOG.error("Problem", e); // Check to see if it's fatal. We might need to wrap it up. try { String alias = ProxoolFacade.getAlias(url); cp = ConnectionPoolManager.getInstance().getConnectionPool(alias); if (FatalSqlExceptionHelper.testException(cp.getDefinition(), e)) { FatalSqlExceptionHelper.throwFatalSQLException(cp.getDefinition().getFatalSqlExceptionWrapper(), e); } // This bit isn't reached if throwFatalSQLException() above throws another exception throw e; } catch (ProxoolException e1) { LOG.error("Problem", e); throw new SQLException(e.toString()); } } catch (ProxoolException e) { LOG.error("Problem", e); throw new SQLException(e.toString()); } } /** * @see Driver#acceptsURL */ public boolean acceptsURL(String url) throws SQLException { return (url.startsWith("proxool")); } /** * @see Driver#getPropertyInfo */ public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException { DriverPropertyInfo[] dpi = new DriverPropertyInfo[18]; ConnectionPool cp = null; try { cp = ConnectionPoolManager.getInstance().getConnectionPool(url); } catch (ProxoolException e) { throw new SQLException(e.toString()); } ConnectionPoolDefinitionIF cpd = cp.getDefinition(); dpi[0] = buildDriverPropertyInfo(ProxoolConstants.DELEGATE_DRIVER_PROPERTY, String.valueOf(cpd.getDriver())); dpi[1] = buildDriverPropertyInfo(ProxoolConstants.DELEGATE_URL_PROPERTY, String.valueOf(cpd.getUrl())); dpi[2] = buildDriverPropertyInfo(ProxoolConstants.MINIMUM_CONNECTION_COUNT_PROPERTY, String.valueOf(cpd.getMinimumConnectionCount())); dpi[3] = buildDriverPropertyInfo(ProxoolConstants.MAXIMUM_CONNECTION_COUNT_PROPERTY, String.valueOf(cpd.getMaximumConnectionCount())); dpi[4] = buildDriverPropertyInfo(ProxoolConstants.MAXIMUM_CONNECTION_LIFETIME_PROPERTY, String.valueOf(cpd.getMaximumConnectionLifetime())); dpi[5] = buildDriverPropertyInfo(ProxoolConstants.MAXIMUM_NEW_CONNECTIONS_PROPERTY, String.valueOf(cpd.getMaximumNewConnections())); dpi[6] = buildDriverPropertyInfo(ProxoolConstants.PROTOTYPE_COUNT_PROPERTY, String.valueOf(cpd.getPrototypeCount())); dpi[7] = buildDriverPropertyInfo(ProxoolConstants.HOUSE_KEEPING_SLEEP_TIME_PROPERTY, String.valueOf(cpd.getHouseKeepingSleepTime())); dpi[8] = buildDriverPropertyInfo(ProxoolConstants.HOUSE_KEEPING_TEST_SQL_PROPERTY, cpd.getHouseKeepingTestSql()); dpi[9] = buildDriverPropertyInfo(ProxoolConstants.RECENTLY_STARTED_THRESHOLD_PROPERTY, String.valueOf(cpd.getRecentlyStartedThreshold())); dpi[10] = buildDriverPropertyInfo(ProxoolConstants.OVERLOAD_WITHOUT_REFUSAL_LIFETIME_PROPERTY, String.valueOf(cpd.getOverloadWithoutRefusalLifetime())); dpi[11] = buildDriverPropertyInfo(ProxoolConstants.MAXIMUM_ACTIVE_TIME_PROPERTY, String.valueOf(cpd.getMaximumActiveTime())); dpi[12] = buildDriverPropertyInfo(ProxoolConstants.VERBOSE_PROPERTY, String.valueOf(cpd.isVerbose())); dpi[13] = buildDriverPropertyInfo(ProxoolConstants.TRACE_PROPERTY, String.valueOf(cpd.isTrace())); dpi[14] = buildDriverPropertyInfo(ProxoolConstants.FATAL_SQL_EXCEPTION_PROPERTY, String.valueOf(cpd.getFatalSqlExceptions())); dpi[15] = buildDriverPropertyInfo(ProxoolConstants.FATAL_SQL_EXCEPTION_PROPERTY, String.valueOf(cpd.getFatalSqlExceptions())); dpi[16] = buildDriverPropertyInfo(ProxoolConstants.STATISTICS_PROPERTY, String.valueOf(cpd.getStatistics())); dpi[17] = buildDriverPropertyInfo(ProxoolConstants.STATISTICS_LOG_LEVEL_PROPERTY, String.valueOf(cpd.getStatisticsLogLevel())); return dpi; } private DriverPropertyInfo buildDriverPropertyInfo(String propertyName, String value) { DriverPropertyInfo dpi = new DriverPropertyInfo(propertyName, ATTRIBUTE_DESCRIPTIONS_RESOURCE.getString (propertyName)); if (value != null) { dpi.value = value; } return dpi; } /** * @see Driver#getMajorVersion */ public int getMajorVersion() { return 1; } /** * @see Driver#getMinorVersion */ public int getMinorVersion() { return 0; } /** * @see Driver#jdbcCompliant */ public boolean jdbcCompliant() { return true; } } /* Revision history: $Log: ProxoolDriver.java,v $ Revision 1.28 2006/01/18 14:40:01 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.27 2004/06/02 20:41:13 billhorsman Don't log SQLExceptions. Leave that up to the client. Revision 1.26 2003/10/16 18:53:21 billhorsman When registering a new pool on the fly, indicate that it is implicit (for exception message handling) Revision 1.25 2003/09/30 18:39:08 billhorsman New test-before-use, test-after-use and fatal-sql-exception-wrapper-class properties. Revision 1.24 2003/09/05 16:59:42 billhorsman Added wrap-fatal-sql-exceptions property Revision 1.23 2003/08/15 10:13:24 billhorsman remove finalize() method Revision 1.22 2003/04/19 12:58:40 billhorsman fixed bug where ConfigurationListener's definitionUpdated was getting called too frequently Revision 1.21 2003/03/10 23:43:12 billhorsman reapplied checkstyle that i'd inadvertently let IntelliJ change... Revision 1.20 2003/03/10 15:26:48 billhorsman refactoringn of concurrency stuff (and some import optimisation) Revision 1.19 2003/03/03 11:11:58 billhorsman fixed licence Revision 1.18 2003/02/26 23:59:37 billhorsman accept now accepts just proxool not proxool: Revision 1.17 2003/02/26 16:05:52 billhorsman widespread changes caused by refactoring the way we update and redefine pool definitions. Revision 1.16 2003/02/07 10:12:59 billhorsman changed updatePoolByDriver sig. Revision 1.15 2003/02/06 17:41:04 billhorsman now uses imported logging Revision 1.14 2003/02/06 15:41:16 billhorsman add statistics-log-level Revision 1.13 2003/01/31 00:28:38 billhorsman updated doc for statistics Revision 1.12 2003/01/30 17:22:01 billhorsman new statistics property Revision 1.11 2003/01/18 15:13:11 billhorsman Signature changes (new ProxoolException thrown) on the ProxoolFacade API. Revision 1.10 2003/01/17 00:38:12 billhorsman wide ranging changes to clarify use of alias and url - this has led to some signature changes (new exceptions thrown) on the ProxoolFacade API. Revision 1.9 2002/12/11 01:48:41 billhorsman added default values for property info documentation Revision 1.8 2002/12/04 13:19:43 billhorsman draft ConfigurationListenerIF stuff for persistent configuration Revision 1.7 2002/12/03 00:41:56 billhorsman fixed getPropertyInfo() for TRACE property and better explanation of FATAL_SQL_EXCEPTION Revision 1.6 2002/11/09 15:55:42 billhorsman added propertyInfo for verbose Revision 1.5 2002/10/27 13:29:38 billhorsman deprecated debug-level in favour of verbose Revision 1.4 2002/10/23 21:04:36 billhorsman checkstyle fixes (reduced max line width and lenient naming convention Revision 1.3 2002/10/17 15:25:37 billhorsman use the url when updating, not the name Revision 1.2 2002/09/18 13:48:56 billhorsman checkstyle and doc Revision 1.1.1.1 2002/09/13 08:13:09 billhorsman new Revision 1.13 2002/07/10 16:14:47 billhorsman widespread layout changes and move constants into ProxoolConstants Revision 1.12 2002/07/04 09:10:48 billhorsman update definition changes Revision 1.11 2002/07/03 10:16:20 billhorsman autoFlush and configuration for logging Revision 1.10 2002/07/02 11:19:08 billhorsman layout code and imports Revision 1.9 2002/07/02 11:14:26 billhorsman added test (andbug fixes) for FileLogger Revision 1.8 2002/07/02 09:05:25 billhorsman All properties now start with "proxool." to avoid possible confusion with delegate driver's properties Revision 1.7 2002/07/02 08:50:33 billhorsman Responsibility for configuring pool is now simplifed and moved to here Revision 1.6 2002/06/28 11:19:47 billhorsman improved doc */ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ProxoolException.java 0000644 0001750 0001750 00000015521 10730503124 030671 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool; import java.io.PrintStream; import java.io.PrintWriter; /** * Proxool exception class that emulates the behaviour of the new cause * facility in jdk 1.4. It is also known as the chained * exception facility, as the cause can, itself, have a cause, and so on, * leading to a "chain" of exceptions, each caused by another. * *
A cause can be associated with a throwable in two ways: via a
* constructor that takes the cause as an argument, or via the
* {@link #initCause(Throwable)} method. New throwable classes that
* wish to allow causes to be associated with them should provide constructors
* that take a cause and delegate (perhaps indirectly) to one of the
* Throwable constructors that takes a cause.
*
* @version $Revision: 1.2 $, $Date: 2003/03/03 11:11:58 $
* @author Christian Nedregaard (christian_nedregaard@email.com)
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.6
*/
public class ProxoolException extends Exception {
/**
* The throwable that caused this ProxoolException to get thrown, or null if this
* ProxoolException was not caused by another throwable, or if the causative
* throwable is unknown.
*/
private Throwable cause = this;
/**
* Constructs a new instance with null as its detail message.
* The cause is not initialized, and may subsequently be initialized by a
* call to {@link #initCause}.
*/
public ProxoolException() {
super();
}
/**
* Constructs a new instance with the specified detail message. The
* cause is not initialized, and may subsequently be initialized by
* a call to {@link #initCause}.
*
* @param message the detail message. The detail message is saved for
* later retrieval by the {@link #getMessage()} method.
*/
public ProxoolException(String message) {
super(message);
}
/**
* Constructs a new instance with the specified detail message and cause.
*
*
Note that the detail message associated with
* cause is not automatically incorporated in
* this throwable's detail message.
*
* @param message the detail message (which is saved for later retrieval
* by the {@link #getMessage()} method).
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A null value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
*/
public ProxoolException(String message, Throwable cause) {
this(message);
this.cause = cause;
}
/**
* Constructs a new throwable with the specified cause and a detail
* message of (cause==null ? null : cause.toString()) (which
* typically contains the class and detail message of cause).
* This constructor is useful for throwables that are little more than
* wrappers for other throwables.
*
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A null value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
*/
public ProxoolException(Throwable cause) {
this(cause == null ? null : cause.toString());
this.cause = cause;
}
/**
* Returns the cause of this exception or null if the
* cause is nonexistent or unknown. (The cause is the throwable that
* caused this exception to get thrown.)
*
*
This implementation returns the cause that was supplied via one of
* the constructors requiring a Throwable, or that was set after
* creation with the {@link #initCause(Throwable)} method.
*
* @return the cause of this throwable or null if the
* cause is nonexistent or unknown.
*/
public Throwable getCause() {
return (cause == this ? null : cause);
}
/**
* Initializes the cause of this exception to the specified value.
* (The cause is the throwable that caused this exception to get thrown.)
*
*
This method can be called at most once. It is generally called from
* within the constructor, or immediately after creating the
* throwable. If this throwable was created
* with {@link #ProxoolException(Throwable)} or
* {@link #ProxoolException(String,Throwable)}, this method cannot be called
* even once.
*
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A null value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @return a reference to this ProxoolException instance.
*/
public synchronized Throwable initCause(Throwable cause) {
if (this.cause != this) {
throw new IllegalStateException("Can't overwrite cause");
}
if (cause == this) {
throw new IllegalArgumentException("Self-causation not permitted");
}
this.cause = cause;
return this;
}
/**
* Prints this ProxoolException and its backtrace to the
* standard error stream.
*
* The backtrace for a ProxoolException with an initialized, non-null cause
* should generally include the backtrace for the cause.
*/
public void printStackTrace() {
printStackTrace(System.err);
}
/**
* Prints this ProxoolException and its backtrace to the specified print stream.
*
* @param stream PrintStream to use for output
*/
public void printStackTrace(PrintStream stream) {
synchronized (stream) {
super.printStackTrace(stream);
Throwable ourCause = getCause();
if (ourCause != null) {
stream.println();
stream.println("Caused by:");
ourCause.printStackTrace(stream);
}
}
}
/**
* Prints this ProxoolException and its backtrace to the specified
* print writer.
*
* @param writer PrintWriter to use for output
*/
public void printStackTrace(PrintWriter writer) {
synchronized (writer) {
super.printStackTrace(writer);
Throwable ourCause = getCause();
if (ourCause != null) {
writer.println();
writer.println("Caused by:");
ourCause.printStackTrace(writer);
}
}
}
}
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ProxoolFacade.java 0000644 0001750 0001750 00000136370 10622435606 030115 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.admin.Admin;
import org.logicalcobwebs.proxool.admin.SnapshotIF;
import org.logicalcobwebs.proxool.admin.StatisticsIF;
import org.logicalcobwebs.proxool.admin.StatisticsListenerIF;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.Statement;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
/**
*
This provides some nice-to-have features that can't be provided by the * {@link java.sql.Driver} {@link ProxoolDriver implementation} of java.sql.Driver. Like starting up * a pool before you need a connection. And getting statistical information.
* *You need to use this class wisely. It is obviously specfic to proxool so it will * stop you switching to another driver. Consider isolating the code that calls this * class so that you can easily remove it if you have to.
* * @version $Revision: 1.87 $, $Date: 2007/05/15 23:00:22 $ * @author billhorsman * @author $Author: billhorsman $ (current maintainer) */ public class ProxoolFacade { private static final Log LOG = LogFactory.getLog(ProxoolFacade.class); private static Map configurators = new HashMap(); private static CompositeProxoolListener compositeProxoolListener = new CompositeProxoolListener(); private static boolean versionLogged = false; /** * This is the thread that has been registered with {@link Runtime} as a * shutdownHook. It is removed during shutdown. */ private static Thread shutdownHook; /** * If you setthis to false then it us up to you to call shutdown explicitly * @see #shutdown(String, int) */ private static boolean shutdownHookEnabled = true; /** * Build a ConnectionPool based on this definition and then start it. * @param url defines the delegate driver and delegate url. * @param info the properties used to configure Proxool (and any for the delegate driver too) - optional * @return the alias for this pool (or the full url if no alias is specified) * @throws ProxoolException if anything goes wrong */ public static synchronized String registerConnectionPool(String url, Properties info) throws ProxoolException { return registerConnectionPool(url, info, true); } /** * Build a ConnectionPool based on this definition and then start it. * @param url defines the delegate driver and delegate url. * @param info the properties used to configure Proxool (and any for the delegate driver too) - optional * @param explicitRegister set to true if we are registering a new pool explicitly, or false * if it's just because we are serving a url that we haven't come across before * @return the alias for this pool (or the full url if no alias is specified) * @throws ProxoolException if anything goes wrong */ protected static synchronized String registerConnectionPool(String url, Properties info, boolean explicitRegister) throws ProxoolException { String alias = getAlias(url); if (!versionLogged) { versionLogged = true; LOG.info("Proxool " + Version.getVersion()); } try { Class.forName(ProxoolDriver.class.getName()); } catch (ClassNotFoundException e) { LOG.error("Couldn't load " + ProxoolDriver.class.getName()); } if (!ConnectionPoolManager.getInstance().isPoolExists(alias)) { ConnectionPoolDefinition cpd = new ConnectionPoolDefinition(url, info, explicitRegister); registerConnectionPool(cpd); } else { throw new ProxoolException("Attempt to register duplicate pool called '" + alias + "'"); } return alias; } protected synchronized static void registerConnectionPool(ConnectionPoolDefinition connectionPoolDefinition) throws ProxoolException { // check isPoolExists once more now we are inside synchronized block. if (!ConnectionPoolManager.getInstance().isPoolExists(connectionPoolDefinition.getAlias())) { Properties jndiProperties = extractJndiProperties(connectionPoolDefinition); ConnectionPool connectionPool = ConnectionPoolManager.getInstance().createConnectionPool(connectionPoolDefinition); connectionPool.start(); compositeProxoolListener.onRegistration(connectionPoolDefinition, connectionPoolDefinition.getCompleteInfo()); if (isConfiguredForJMX(connectionPoolDefinition.getCompleteInfo())) { registerForJmx(connectionPoolDefinition.getAlias(), connectionPoolDefinition.getCompleteInfo()); } if (jndiProperties != null) { registerDataSource(connectionPoolDefinition.getAlias(), jndiProperties); } } else { LOG.debug("Ignoring duplicate attempt to register " + connectionPoolDefinition.getAlias() + " pool"); } } /** * With no configurator or properties (using default values) * @see #registerConnectionPool(java.lang.String, java.util.Properties) */ public static void registerConnectionPool(String url) throws ProxoolException { registerConnectionPool(url, null); } /** * Extracts the pool alias from the url: * * proxool.alias:driver:url -> alias * proxool.alias -> alias * * @return the alias defined within the url * @throws ProxoolException if we couldn't find the alias */ protected static String getAlias(String url) throws ProxoolException { String alias = null; final String prefix = ProxoolConstants.PROXOOL + ProxoolConstants.ALIAS_DELIMITER; // Check that the prefix is there if (url.startsWith(prefix)) { // Check for the alias int endOfPrefix = url.indexOf(ProxoolConstants.URL_DELIMITER); if (endOfPrefix > -1) { alias = url.substring(prefix.length(), endOfPrefix); } else { alias = url.substring(prefix.length()); } } // Check we found it. if (alias == null || alias.length() == 0) { throw new ProxoolException("The URL '" + url + "' is not in the correct form. It should be: 'proxool.alias:driver:url'"); } return alias; } /** * Remove a connection pool. Kills all the connections. Resets everything. * @param finalizer the name of the thread requesting shutdown (for logging) * @param connectionPool the pool to remove * @param delay the time to wait for connections to become inactive before killing it (milliseconds) */ private static void removeConnectionPool(String finalizer, ConnectionPool connectionPool, int delay) { final String alias = connectionPool.getDefinition().getAlias(); if (connectionPool != null) { try { compositeProxoolListener.onShutdown(alias); connectionPool.shutdown(delay, finalizer); } catch (Throwable t) { LOG.error("Problem trying to shutdown '" + alias + "' connection pool", t); } } connectionPool = null; } /** * Remove a connection pool. Kills all the connections. Resets everything. * @param alias the pool to remove * @param delay the time to wait for connections to become inactive before killing it (milliseconds) * @throws ProxoolException if we couldn't find the pool */ public static void removeConnectionPool(String alias, int delay) throws ProxoolException { removeConnectionPool(Thread.currentThread().getName(), ConnectionPoolManager.getInstance().getConnectionPool(alias), delay); } /** * Removes all connection pools. Kills all the connections. Resets everything. * @param delay the time to wait for connections to become inactive before killing it (milliseconds) * @deprecated use the better named {@link #shutdown(int) shutdown()} instead. */ public static void removeAllConnectionPools(int delay) { shutdown(Thread.currentThread().getName(), delay); } /** * Removes all connection pools. Kills all the connections. Resets everything. * Like {@link #shutdown(java.lang.String, int)} but passes the current thread name * and a delay of zero. */ public static void shutdown() { shutdown(Thread.currentThread().getName(), 0); } /** * Removes all connection pools. Kills all the connections. Resets everything. * Like {@link #shutdown(java.lang.String, int)} but passes the current thread name. * @param delay the time to wait for connections to become inactive before killing it (milliseconds) */ public static void shutdown(int delay) { shutdown(Thread.currentThread().getName(), delay); } /** * Removes all connection pools. Kills all the connections. Resets everything. * @param finalizer used to identify who is causing the pools to be removed (helps logging) * @param delay the time to wait for connections to become inactive before killing it (milliseconds) */ protected static void shutdown(String finalizer, int delay) { ConnectionPool[] cps = ConnectionPoolManager.getInstance().getConnectionPools(); for (int i = 0; i < cps.length; i++) { removeConnectionPool(finalizer, cps[i], delay); } // If a shutdown hook was registered then remove it try { if (shutdownHook != null) { ShutdownHook.remove(shutdownHook); } } catch (Throwable t) { if (LOG.isDebugEnabled()) { LOG.debug("Unanticipated error during removal of ShutdownHook. Ignoring it.", t); } } // Stop threads PrototyperController.shutdown(); HouseKeeperController.shutdown(); } /** * If you call this then you'll have to call shutdown explicitly * @see #shutdown(String, int) */ public static void disableShutdownHook() { ProxoolFacade.shutdownHookEnabled = false; } /** * Call this if you change your mind about {@link #disableShutdownHook() disabling} it. * The default behaviour is to have it enabled so unless you have disabled it then * there's nothing to do. */ public static void enableShutdownHook() { ProxoolFacade.shutdownHookEnabled = true; } /** * Whether the {@link ShutdownHook} should do anything. * @see #disableShutdownHook() * @see #enableShutdownHook() * @return true if the shutdown hook should clean up */ public static boolean isShutdownHookEnabled() { return shutdownHookEnabled; } /** * Like {@link #removeConnectionPool(java.lang.String, int)} but uses no delay. (Kills * everything as quickly as possible). * @param alias to identify the pool * @throws ProxoolException if we couldn't find the pool */ public static void removeConnectionPool(String alias) throws ProxoolException { removeConnectionPool(alias, 0); } /** * Get real-time statistical information about how a pool is performing. * @param alias to identify the pool * @return the statistics * @throws ProxoolException if we couldn't find the pool * @deprecated use {@link #getSnapshot} */ public static ConnectionPoolStatisticsIF getConnectionPoolStatistics(String alias) throws ProxoolException { return ConnectionPoolManager.getInstance().getConnectionPool(alias); } /** * Get real-time statistical information about how a pool is performing. * and extract the information piece by piece. * @param alias to identify the pool * @return a horrible string describing the statistics * @throws ProxoolException if we couldn't find the pool * @deprecated use {@link #getSnapshot} */ public static String getConnectionPoolStatisticsDump(String alias) throws ProxoolException { return ConnectionPoolManager.getInstance().getConnectionPool(alias).displayStatistics(); } /** * Get the definition of a pool. * @param alias identifies the pool * @throws ProxoolException if we couldn't find the pool */ public static ConnectionPoolDefinitionIF getConnectionPoolDefinition(String alias) throws ProxoolException { return ConnectionPoolManager.getInstance().getConnectionPool(alias).getDefinition(); } /** * Get details on each connection within the pool. This can tell you which ones are active, how long they have * been active, etc. * @param alias identifies the pool * @return a collection of {@link ConnectionInfoIF ConnectionInfoIFs} * @throws ProxoolException if we couldn't find the pool * @deprecated use {@link #getSnapshot(java.lang.String, boolean) snapshot} instead. */ public static Collection getConnectionInfos(String alias) throws ProxoolException { return ConnectionPoolManager.getInstance().getConnectionPool(alias).getConnectionInfos(); } /** * Kill all connections in a pool. The pool continues to work however, and new connections will be * made as required. * @param alias the pool containing the connection * @param merciful if true will only kill connections that aren't active * @throws ProxoolException if we couldn't find the pool * @deprecated use {@link #killAllConnections(java.lang.String, java.lang.String, boolean) alternative} * to provide better auditing in log */ public static void killAllConnections(String alias, boolean merciful) throws ProxoolException { killAllConnections(alias, "of thread " + Thread.currentThread().getName(), merciful); } /** * Kill all connections in a pool. The pool continues to work however, and new connections will be * made as required. * @param alias the pool containing the connection * @param reason provides audit in log of why connections were killed * @param merciful if true will only kill connections that aren't active * @throws ProxoolException if we couldn't find the pool */ public static void killAllConnections(String alias, String reason, boolean merciful) throws ProxoolException { ConnectionPoolManager.getInstance().getConnectionPool(alias).expireAllConnections(ConnectionListenerIF.MANUAL_EXPIRY, reason, merciful); } /** * Like {@link #killAllConnections} but defaults to merciful. * @param alias to identify the pool * @throws ProxoolException if we couldn't find the pool * @deprecated use {@link #killAllConnections(java.lang.String, java.lang.String) alternative} * to provide better auditing in log */ public static void killAllConnections(String alias) throws ProxoolException { killAllConnections(alias, "of thread " + Thread.currentThread().getName(), MERCIFUL); } /** * Like {@link #killAllConnections} but defaults to merciful. * @param alias to identify the pool * @param reason provides audit in log of why connections were killed * @throws ProxoolException if we couldn't find the pool */ public static void killAllConnections(String alias, String reason) throws ProxoolException { killAllConnections(alias, reason, MERCIFUL); } /** * Kill a single connection * @param alias the pool containing the connection * @param id the id of the specific connection * @param merciful if true will only kill connections that aren't active * @return true if the connection was killed, or false if it couldn't be found. * @throws ProxoolException if we couldn't find the pool */ public static boolean killConnecton(String alias, long id, boolean merciful) throws ProxoolException { // Let's be explicit about what we're doing here boolean forceExpiry = !merciful; return ConnectionPoolManager.getInstance().getConnectionPool(alias).expireConnection(id, forceExpiry); } /** * Kill a single connection * @param connection the connection to kill * @param merciful if true will only kill connections that aren't active * @return true if the connection was killed, or false if it couldn't be found. * @throws ProxoolException if we didn't recognise the connection */ public static boolean killConnecton(Connection connection, boolean merciful) throws ProxoolException { WrappedConnection wrappedConnection = ProxyFactory.getWrappedConnection(connection); if (wrappedConnection != null) { long id = wrappedConnection.getId(); String alias = wrappedConnection.getAlias(); return killConnecton(alias, id, merciful); } else { throw new ProxoolException("Attempt to kill unrecognised exception " + connection); } } /** * Add a listener that gets called everytime a global Proxool event ocours. * @param proxoolListener the listener to add. */ public static void addProxoolListener(ProxoolListenerIF proxoolListener) { compositeProxoolListener.addListener(proxoolListener); } /** * Remove a registeredProxoolListenerIF.
* @param proxoolListener the listener to remove.
* @return whether the listener was found or removed or not.
*/
public static boolean removeProxoolListener(ProxoolListenerIF proxoolListener) {
return compositeProxoolListener.removeListener(proxoolListener);
}
/**
* @deprecated use {@link #addStateListener(String, StateListenerIF)} instead.
*/
public static void setStateListener(String alias, StateListenerIF stateListener) throws ProxoolException {
addStateListener(alias, stateListener);
}
/**
* Add a listener that monitors the change of state of the pool (quiet, busy, overloaded, or down)
* @param alias identifies the pool
* @param stateListener the new listener
* @throws ProxoolException if we couldn't find the pool
*/
public static void addStateListener(String alias, StateListenerIF stateListener) throws ProxoolException {
ConnectionPool cp = ConnectionPoolManager.getInstance().getConnectionPool(alias);
cp.addStateListener(stateListener);
}
/**
* Remove a listener that monitors the change of state of the pool (quiet, busy, overloaded, or down)
* @param alias identifies the pool
* @param stateListener the listener to be removed.
* @throws ProxoolException if we couldn't find the pool
* @return wether the listnener was found and removed or not.
*/
public static boolean removeStateListener(String alias, StateListenerIF stateListener) throws ProxoolException {
ConnectionPool cp = ConnectionPoolManager.getInstance().getConnectionPool(alias);
return cp.removeStateListener(stateListener);
}
/**
* @deprecated use {@link #addConnectionListener(String, ConnectionListenerIF)} instead.
*/
public static void setConnectionListener(String alias, ConnectionListenerIF connectionListener) throws ProxoolException {
addConnectionListener(alias, connectionListener);
}
/**
* Add a listener that monitors each time a connection is made or destroyed.
* @param alias identifies the pool
* @param connectionListener the new listener
* @throws ProxoolException if we couldn't find the pool
*/
public static void addConnectionListener(String alias, ConnectionListenerIF connectionListener) throws ProxoolException {
ConnectionPool cp = ConnectionPoolManager.getInstance().getConnectionPool(alias);
cp.addConnectionListener(connectionListener);
}
/**
* Remove a listener that monitors each time a connection is made or destroyed.
* @param alias identifies the pool
* @param connectionListener the listener to be removed
* @throws ProxoolException if we couldn't find the pool
* @return wether the listnener was found and removed or not.
*/
public static boolean removeConnectionListener(String alias, ConnectionListenerIF connectionListener) throws ProxoolException {
ConnectionPool cp = ConnectionPoolManager.getInstance().getConnectionPool(alias);
return cp.removeConnectionListener(connectionListener);
}
/**
* @deprecated use {@link #addConfigurationListener(String, ConfigurationListenerIF)} instead.
*/
public static void setConfigurationListener(String alias, ConfigurationListenerIF configurationListener) throws ProxoolException {
addConfigurationListener(alias, configurationListener);
}
/**
* Adds a listener that gets called everytime the configuration changes.
* @param alias identifies the pool
* @param configurationListener the new listener
* @throws ProxoolException if we couldn't find the pool
*/
public static void addConfigurationListener(String alias, ConfigurationListenerIF configurationListener) throws ProxoolException {
if (ConnectionPoolManager.getInstance().isPoolExists(alias)) {
CompositeConfigurationListener compositeConfigurationListener = (CompositeConfigurationListener)
configurators.get(alias);
if (compositeConfigurationListener == null) {
compositeConfigurationListener = new CompositeConfigurationListener();
configurators.put(alias, compositeConfigurationListener);
}
compositeConfigurationListener.addListener(configurationListener);
} else {
throw new ProxoolException(ConnectionPoolManager.getInstance().getKnownPools(alias));
}
}
/**
* Broadcast a configuration change
* @param alias identifies the pool
* @param connectionPoolDefinition the definition
* @param completeInfo all properties
* @param changedInfo only changed properties (since the last
* time this method was called)
*/
protected static void definitionUpdated(String alias, ConnectionPoolDefinitionIF connectionPoolDefinition,
Properties completeInfo, Properties changedInfo) {
CompositeConfigurationListener ccl = (CompositeConfigurationListener) configurators.get(alias);
if (ccl != null) {
ccl.definitionUpdated(connectionPoolDefinition, completeInfo, changedInfo);
}
}
/**
* Remove a listener that gets called everytime the configuration changes.
* @param alias identifies the pool.
* @param configurationListener the listener to be removed.
* @throws ProxoolException if we couldn't find the pool
* @return wether the listnener was found and removed or not.
*
*/
public static boolean removeConfigurationListener(String alias, ConfigurationListenerIF configurationListener) throws ProxoolException {
boolean removed = false;
if (ConnectionPoolManager.getInstance().isPoolExists(alias)) {
CompositeConfigurationListener compositeConfigurationListener = (CompositeConfigurationListener)
configurators.get(alias);
if (compositeConfigurationListener != null) {
removed = compositeConfigurationListener.removeListener(configurationListener);
}
} else {
throw new ProxoolException(ConnectionPoolManager.getInstance().getKnownPools(alias));
}
return removed;
}
/**
* @see #killAllConnections(java.lang.String)
*/
private static final boolean MERCIFUL = true;
/**
* Redefine the behaviour of the pool. All existing properties (for Proxool
* and the delegate driver are reset to their default) and reapplied
* based on the parameters sent here.
*
* @param url the url that defines the pool (or the abbreviated ""proxool.alias")
* @param info the new properties
* @see #updateConnectionPool
*/
public static void redefineConnectionPool(String url, Properties info) throws ProxoolException {
String alias = getAlias(url);
ConnectionPool cp = ConnectionPoolManager.getInstance().getConnectionPool(alias);
try {
// Clone the old one
ConnectionPoolDefinition cpd = (ConnectionPoolDefinition) cp.getDefinition().clone();
cpd.redefine(url, info);
cp.setDefinition(cpd);
} catch (CloneNotSupportedException e) {
throw new ProxoolException("Funny, why couldn't we clone a definition?", e);
}
}
/**
* Update the behaviour of the pool. Only properties that are defined here are overwritten. That is, properties
* that were defined before but are not mentioned here are retained.
*
* @param url the url that defines the pool (or the abbreviated ""proxool.alias")
* @param info the new properties
* @see #redefineConnectionPool
*/
public static void updateConnectionPool(String url, Properties info) throws ProxoolException {
String alias = getAlias(url);
ConnectionPool cp = ConnectionPoolManager.getInstance().getConnectionPool(alias);
try {
// Clone the old one
ConnectionPoolDefinition cpd = (ConnectionPoolDefinition) cp.getDefinition().clone();
cpd.update(url, info);
cp.setDefinition(cpd);
} catch (CloneNotSupportedException e) {
throw new ProxoolException("Funny, why couldn't we clone a definition?", e);
}
}
protected void finalize() throws Throwable {
super.finalize();
LOG.debug("Finalising");
}
/**
* Returns the driver provided statement that Proxool wraps up before it gives it to you.
* @return delegate statement
* @deprecated Just cast the statement that you are given into the driver specific one.
*/
public static Statement getDelegateStatement(Statement statement) throws ProxoolException {
try {
return ProxyFactory.getDelegateStatement(statement);
} catch (IllegalArgumentException e) {
throw new ProxoolException("Statement argument is not one provided by Proxool (it's a " + statement.getClass() + ")");
}
}
/**
* Returns the driver provided connection that Proxool wraps up before it gives it to you.
* @return delegate connection
* @deprecated Just cast the connection that you are given into the driver specific one.
*/
public static Connection getDelegateConnection(Connection connection) throws ProxoolException {
try {
return ProxyFactory.getDelegateConnection(connection);
} catch (IllegalArgumentException e) {
throw new ProxoolException("Connection argument is not one provided by Proxool (it's a " + connection.getClass() + ")");
}
}
/**
* Get the connection ID for a connection
* @param connection the connection that was served
* @return the ID
* @throws ProxoolException if the connection wasn't recognised.
*/
public static long getId(Connection connection) throws ProxoolException {
try {
return ProxyFactory.getWrappedConnection(connection).getId();
} catch (NullPointerException e) {
throw new ProxoolException("Connection argument is not one provided by Proxool (it's a " + connection.getClass() + ")");
} catch (IllegalArgumentException e) {
throw new ProxoolException("Connection argument is not one provided by Proxool (it's a " + connection.getClass() + ")");
}
}
/**
* Get the alias for the connection pool that served a connection
* @param connection the connection that was served
* @return the alias
* @throws ProxoolException if the connection wasn't recognised.
*/
public static String getAlias(Connection connection) throws ProxoolException {
try {
return ProxyFactory.getWrappedConnection(connection).getAlias();
} catch (NullPointerException e) {
throw new ProxoolException("Connection argument is not one provided by Proxool (it's a " + connection.getClass() + ")");
} catch (IllegalArgumentException e) {
throw new ProxoolException("Connection argument is not one provided by Proxool (it's a " + connection.getClass() + ")");
}
}
/**
* Get a list of all the registered pools
* @return an array of aliases
* @since Proxool 0.7
*/
public static String[] getAliases() {
return ConnectionPoolManager.getInstance().getConnectionPoolNames();
}
/**
* Get a particular set of performance statistics for this pool
* @param alias identifies the pool
* @param token identifies which set, as defined in the configuration (see {@link ConnectionPoolDefinitionIF#getStatistics definition})
* @return a sample containing the statistics
* @throws ProxoolException if we couldn't find the pool
*/
public static StatisticsIF getStatistics(String alias, String token) throws ProxoolException {
return ConnectionPoolManager.getInstance().getConnectionPool(alias).getAdmin().getStatistics(token);
}
/**
* Get all the lastest performance statistics for this pool
* @param alias identifies the pool
* @return a sample containing the statistics, or a zero length array if there none
* @throws ProxoolException if we couldn't find the pool
*/
public static StatisticsIF[] getStatistics(String alias) throws ProxoolException {
final Admin monitor = ConnectionPoolManager.getInstance().getConnectionPool(alias).getAdmin();
if (monitor != null) {
return monitor.getStatistics();
} else {
return new StatisticsIF[0];
}
}
/**
* Add a listener that receives statistics as they are produced
* @param statisticsListener the new listener
* @throws ProxoolException if the pool couldn't be found
*/
public static void addStatisticsListener(String alias, StatisticsListenerIF statisticsListener) throws ProxoolException {
// TODO investigate what happens if we add a statistics monitor after we register a listener
final Admin monitor = ConnectionPoolManager.getInstance().getConnectionPool(alias).getAdmin();
if (monitor != null) {
monitor.addStatisticsListener(statisticsListener);
} else {
throw new ProxoolException("Statistics are switched off, your can't add a listener");
}
}
/**
* Gives a snapshot of what the pool is doing
* @param alias identifies the pool
* @param detail if true then include detail of each connection. Note it you ask for
* detail then the pool must necessarily be locked for the duration it takes to gather
* the information (which isn't very long). You probably shouldn't do it that often (like
* not every second or something). Being locked means that connections cannot be
* served or returned (it doesn't mean that they can't be active).
* @return the current status of the pool
* @throws ProxoolException if we couldn't find the pool
*/
public static SnapshotIF getSnapshot(String alias, boolean detail) throws ProxoolException {
SnapshotIF snapshot = null;
ConnectionPool cp = ConnectionPoolManager.getInstance().getConnectionPool(alias);
if (detail) {
try {
// Only try for 10 seconds!
long start = System.currentTimeMillis();
if (cp.attemptConnectionStatusReadLock(10000)) {
snapshot = Admin.getSnapshot(cp, cp.getDefinition(), cp.getConnectionInfos());
} else {
LOG.warn("Give up waiting for detailed snapshot after " + (System.currentTimeMillis() - start) + " milliseconds. Serving standard snapshot instead.");
}
} finally {
cp.releaseConnectionStatusReadLock();
}
}
if (snapshot == null) {
snapshot = Admin.getSnapshot(cp, cp.getDefinition(), null);
}
return snapshot;
}
/**
* Calls {@link #getSnapshot(java.lang.String, boolean) getSnapshot}
* using false for the detail parameter.
* @see #getSnapshot(java.lang.String, boolean)
*/
public static SnapshotIF getSnapshot(String alias) throws ProxoolException {
return getSnapshot(alias, false);
}
// all jmx operations are done through reflection
// to avoid making the facade dependant on the JMX classes
private static boolean registerForJmx(String alias, Properties properties) {
boolean success = false;
try {
Class jmxHelperClass = Class.forName("org.logicalcobwebs.proxool.admin.jmx.ProxoolJMXHelper");
Method registerMethod = jmxHelperClass.getDeclaredMethod("registerPool", new Class[]{String.class, Properties.class});
registerMethod.invoke(null, new Object[]{alias, properties});
success = true;
} catch (Exception e) {
LOG.error("JMX registration of " + alias + " pool failed.", e);
}
return success;
}
// all JNDI operations are done through reflection
// to avoid making the facade dependant on the JNDI classes
private static boolean registerDataSource(String alias, Properties jndiProperties) {
boolean success = false;
try {
Class jndiHelperClass = Class.forName("org.logicalcobwebs.proxool.admin.jndi.ProxoolJNDIHelper");
Method registerMethod = jndiHelperClass.getDeclaredMethod("registerDatasource", new Class[]{String.class,
Properties.class});
registerMethod.invoke(null, new Object[]{alias, jndiProperties});
success = true;
} catch (Exception e) {
LOG.error("JNDI DataSource binding of " + alias + " pool failed.", e);
}
return success;
}
/**
* Get the JNDI properties for the given pool definition if it is configured for JNDI registration.
* Will remove generic JNDI properties from the delegate properties so that they will not be passed to the
* delegate driver.
* @param connectionPoolDefinition the pool definition to get the eventual JNDI configuration from.
* @return the JNDI properties, or null if the given definition was not configured for JNDI.
*/
private static Properties extractJndiProperties(ConnectionPoolDefinition connectionPoolDefinition) {
if (connectionPoolDefinition.getJndiName() == null) {
return null;
}
Properties jndiProperties = new Properties();
jndiProperties.setProperty(ProxoolConstants.JNDI_NAME, connectionPoolDefinition.getJndiName());
if (connectionPoolDefinition.getDelegateProperties() != null) {
Properties delegateProperties = connectionPoolDefinition.getDelegateProperties();
// we must retrieve all the relevant property names before removing them from
// the given properties to avoid ConcurrentModificationException
String propertyName = null;
List propertyNamesList = new ArrayList(10);
Iterator keySetIterator = delegateProperties.keySet().iterator();
while (keySetIterator.hasNext()) {
propertyName = (String) keySetIterator.next();
if (propertyName.startsWith(ProxoolConstants.JNDI_PROPERTY_PREFIX)) {
propertyNamesList.add(propertyName);
}
}
for (int i = 0; i < propertyNamesList.size(); i++) {
propertyName = (String) propertyNamesList.get(i);
if (propertyName.startsWith(ProxoolConstants.JNDI_PROPERTY_PREFIX)) {
jndiProperties.setProperty(propertyName.substring(ProxoolConstants.JNDI_PROPERTY_PREFIX.length()),
(String) delegateProperties.getProperty(propertyName));
delegateProperties.remove(propertyName);
}
}
}
return jndiProperties;
}
/**
* Get wether the given pool properties contains configuration for JMX instrumentation of the pool.
* @param poolProperties the properties to check for JMX configuration.
* @return wether the given pool properties contains configuration for JMX instrumentation or not.
*/
private static boolean isConfiguredForJMX(Properties poolProperties) {
final String jmxProperty = poolProperties.getProperty(ProxoolConstants.JMX_PROPERTY);
if (jmxProperty != null && jmxProperty.equalsIgnoreCase("true")) {
return true;
} else {
return false;
}
}
/**
* By remembering the most recent {@link ShutdownHook} ProxoolFacade
* will know to disable it when it is {@link #shutdown}. It will gracefully
* cope with the fact that it may be shutting down by the request of the
* sutdownHook. If you don't do this and do several "hot deploys" then you
* end up with a series of shutdown hooks. We only every want one.
* @param t the thread that will be run as a shutdown hook
* @see ShutdownHook
*/
protected static void setShutdownHook(Thread t) {
shutdownHook = t;
}
}
/*
Revision history:
$Log: ProxoolFacade.java,v $
Revision 1.87 2007/05/15 23:00:22 billhorsman
Made removeStateListener() static like the other removeFooListener() methods. Credit to gazzamop@hotmail.com (bug 1716868).
Revision 1.86 2007/01/25 23:38:24 billhorsman
Scrapped onAboutToDie and altered onDeath signature instead. Now includes reasonCode (see ConnectionListenerIF)
Revision 1.85 2006/11/02 10:00:34 billhorsman
Added ProxoolFacade.disableShutdownHook.
Revision 1.84 2006/01/18 14:40:01 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.83 2005/09/26 09:54:14 billhorsman
Avoid suspected deadlock when getting a detailed snapshot. Only attempt to get the concurrent lock for 10 seconds before giving up.
Revision 1.82 2005/05/04 16:32:31 billhorsman
Clone the definition when redefining or updating the pool.
Revision 1.81 2004/09/29 15:43:25 billhorsman
Recheck isPoolExists inside synchronized registerConnectionPool method. Credit Juergen Hoeller.
Revision 1.80 2004/06/02 20:47:05 billhorsman
Override shutdown with a zero-parameter version for Spring integration.
Revision 1.79 2004/03/26 15:58:56 billhorsman
Fixes to ensure that house keeper and prototyper threads finish after shutdown.
Revision 1.78 2004/03/23 21:25:54 billhorsman
Added getAlias() call.
Revision 1.77 2004/03/23 21:19:45 billhorsman
Added disposable wrapper to proxied connection. And made proxied objects implement delegate interfaces too.
Revision 1.76 2004/03/15 02:45:19 chr32
Added handling of Proxool managed JNDI DataSources.
Revision 1.75 2004/02/12 12:54:49 billhorsman
Fix merciful/forceExpiry confusion
Revision 1.74 2003/10/30 00:16:13 billhorsman
Throw a friendlier exception if you try and add a statistics listener to a pool with no statistics
Revision 1.73 2003/10/16 18:52:35 billhorsman
Fixed a bug: the redefine() method was actually calling the update() method. Also, added checks to make the
"Attempt to use a pool with incomplete definition" exception a bit more descriptive. It's often because you
are referring to an unregistered pool simply by using an alias.
Revision 1.72 2003/09/07 22:09:21 billhorsman
Remove any registered ShutdownHooks during shutdown.
Revision 1.71 2003/08/30 14:54:04 billhorsman
Checkstyle
Revision 1.70 2003/08/28 10:55:49 billhorsman
comment out JNDI stuff for now
Revision 1.69 2003/08/27 18:03:20 billhorsman
added new getDelegateConnection() method
Revision 1.68 2003/07/23 12:38:50 billhorsman
some fixes, but more to come
Revision 1.67 2003/07/23 06:54:48 billhorsman
draft JNDI changes (shouldn't effect normal operation)
Revision 1.66 2003/04/10 21:49:34 billhorsman
refactored registration slightly to allow DataSource access
Revision 1.65 2003/03/11 14:51:53 billhorsman
more concurrency fixes relating to snapshots
Revision 1.64 2003/03/10 15:26:49 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.63 2003/03/03 11:11:58 billhorsman
fixed licence
Revision 1.62 2003/02/28 10:42:59 billhorsman
ConnectionPoolManager now passes ProxoolFacade an
array of ConnectionPools rather than a Collection
to avoid a ConcurrentModificationException during
shutdown.
Revision 1.61 2003/02/27 17:19:18 billhorsman
new overloaded getSnapshot method
Revision 1.60 2003/02/26 16:05:53 billhorsman
widespread changes caused by refactoring the way we
update and redefine pool definitions.
Revision 1.59 2003/02/24 18:03:24 chr32
Added JMX operations.
Revision 1.58 2003/02/24 01:15:33 chr32
Added support for ProxoolListenerIF.
Revision 1.57 2003/02/19 23:46:10 billhorsman
renamed monitor package to admin
Revision 1.56 2003/02/19 13:48:28 chr32
Added 'removeConfigurationListener' method.
Revision 1.55 2003/02/18 16:50:00 chr32
Added possibility to remove connection and state listeners.
Revision 1.54 2003/02/14 14:19:42 billhorsman
automatically load ProxoolDriver
Revision 1.53 2003/02/14 13:26:23 billhorsman
better exception for incorrect url
Revision 1.52 2003/02/12 12:28:27 billhorsman
added url, proxyHashcode and delegateHashcode to
ConnectionInfoIF
Revision 1.51 2003/02/07 17:26:05 billhorsman
deprecated removeAllConnectionPools in favour of
shutdown (and dropped unreliable finalize() method)
Revision 1.50 2003/02/07 15:12:41 billhorsman
fix statisticsLogLevel property recognition again
Revision 1.49 2003/02/07 14:45:40 billhorsman
fix statisticsLogLevel property recognition
Revision 1.48 2003/02/07 14:16:46 billhorsman
support for StatisticsListenerIF
Revision 1.47 2003/02/07 10:27:47 billhorsman
change in shutdown procedure to allow re-registration
Revision 1.46 2003/02/07 01:48:15 chr32
Started using new composite listeners.
Revision 1.45 2003/02/06 17:41:04 billhorsman
now uses imported logging
Revision 1.44 2003/02/06 15:46:43 billhorsman
checkstyle
Revision 1.43 2003/02/06 15:41:16 billhorsman
add statistics-log-level
Revision 1.42 2003/02/05 17:05:02 billhorsman
registerConnectionPool is now synchronized
Revision 1.41 2003/02/05 00:20:01 billhorsman
copes with pools with no statistics
Revision 1.40 2003/02/04 17:18:29 billhorsman
move ShutdownHook init code
Revision 1.39 2003/02/04 15:04:17 billhorsman
New ShutdownHook
Revision 1.38 2003/01/31 16:53:17 billhorsman
checkstyle
Revision 1.37 2003/01/31 11:50:39 billhorsman
changes for snapshot improvements
Revision 1.36 2003/01/31 00:18:27 billhorsman
statistics is now a string to allow multiple,
comma-delimited values (plus allow access to all
statistics)
Revision 1.35 2003/01/30 17:50:28 billhorsman
spelling
Revision 1.34 2003/01/30 17:48:50 billhorsman
configuration listener now linked to alias not url
Revision 1.33 2003/01/30 17:22:23 billhorsman
add statistics support
Revision 1.32 2003/01/27 18:26:36 billhorsman
refactoring of ProxyConnection and ProxyStatement to
make it easier to write JDK 1.2 patch
Revision 1.31 2003/01/23 11:08:26 billhorsman
new setConfiguratorListener method (and remove from optional
parameter when registering pool)
Revision 1.30 2003/01/19 15:21:07 billhorsman
doc
Revision 1.29 2003/01/18 15:13:12 billhorsman
Signature changes (new ProxoolException
thrown) on the ProxoolFacade API.
Revision 1.28 2003/01/17 00:38:12 billhorsman
wide ranging changes to clarify use of alias and url -
this has led to some signature changes (new exceptions
thrown) on the ProxoolFacade API.
Revision 1.27 2003/01/15 14:51:40 billhorsman
checkstyle
Revision 1.26 2003/01/15 12:20:06 billhorsman
deprecated getConnectionPoolStatisticsDump
Revision 1.25 2003/01/14 23:50:58 billhorsman
logs version
Revision 1.24 2002/12/16 17:15:03 billhorsman
fix for url
Revision 1.23 2002/12/16 16:47:22 billhorsman
fix for updating properties with zero length strings
Revision 1.22 2002/12/16 16:42:30 billhorsman
allow URL updates to pool
Revision 1.21 2002/12/16 11:46:00 billhorsman
send properties to definitionUpdated
Revision 1.20 2002/12/16 11:16:51 billhorsman
checkstyle
Revision 1.19 2002/12/16 11:15:19 billhorsman
fixed getDelegateStatement
Revision 1.18 2002/12/16 10:57:48 billhorsman
add getDelegateStatement to allow access to the
delegate JDBC driver's Statement
Revision 1.17 2002/12/12 10:49:43 billhorsman
now includes properties in definitionChanged event
Revision 1.16 2002/12/04 13:19:43 billhorsman
draft ConfigurationListenerIF stuff for persistent configuration
Revision 1.15 2002/11/13 19:12:24 billhorsman
fix where update properties weren't being recognised
when the properties object was the same as the original
Revision 1.14 2002/11/13 11:28:38 billhorsman
trace property wasn't being configured
Revision 1.13 2002/11/09 15:56:31 billhorsman
log if serConnectionListener couldn't find pool
Revision 1.12 2002/11/03 10:46:57 billhorsman
hide passwords in log
Revision 1.11 2002/11/02 13:57:33 billhorsman
checkstyle
Revision 1.10 2002/10/29 08:54:45 billhorsman
fix to getAlias so that it correctly extracts alias from "proxool.alias" form
Revision 1.9 2002/10/28 19:43:30 billhorsman
configuring of pool now gets logged to that pool's logger (rather than general log)
Revision 1.8 2002/10/27 13:29:38 billhorsman
deprecated debug-level in favour of verbose
Revision 1.7 2002/10/27 13:01:23 billhorsman
layout
Revision 1.6 2002/10/25 15:59:32 billhorsman
made non-public where possible
Revision 1.5 2002/10/25 10:12:52 billhorsman
Improvements and fixes to the way connection pools close down. Including new ReloadMonitor to detect when a class is reloaded. Much better logging too.
Revision 1.4 2002/10/24 17:40:31 billhorsman
Fixed recognition of existing pool (which was resulting in an extra configuration step - but which didn't cause any problems)
Revision 1.3 2002/10/23 21:04:36 billhorsman
checkstyle fixes (reduced max line width and lenient naming convention
Revision 1.2 2002/10/17 15:27:31 billhorsman
better reporting of property settings
Revision 1.1.1.1 2002/09/13 08:13:19 billhorsman
new
Revision 1.11 2002/08/24 20:07:28 billhorsman
removed debug to stdout
Revision 1.10 2002/08/24 19:44:13 billhorsman
fixes for logging
Revision 1.9 2002/07/10 16:14:47 billhorsman
widespread layout changes and move constants into ProxoolConstants
Revision 1.8 2002/07/05 13:24:32 billhorsman
doc
Revision 1.7 2002/07/04 09:04:20 billhorsman
Now throws an SQLException if you ask for a ConnectionPoolDefinition, ConnectionPoolStatistics that doesn't exist. This makes it easier to show the list of possible ones you can choose.
Revision 1.6 2002/07/02 11:19:08 billhorsman
layout code and imports
Revision 1.5 2002/07/02 11:14:26 billhorsman
added test (andbug fixes) for FileLogger
Revision 1.4 2002/07/02 09:13:08 billhorsman
removed redundant import
Revision 1.3 2002/07/02 08:52:42 billhorsman
Added lots more methods and moved configuration stuff here
Revision 1.2 2002/06/28 11:19:47 billhorsman
improved doc
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ProxoolListenerIF.java 0000644 0001750 0001750 00000002502 10730503125 030733 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import java.util.Properties;
/**
* Listener for global Proxool events.
* @version $Revision: 1.2 $, $Date: 2003/03/03 11:11:58 $
* @author Christian Nedregaard (christian_nedregaard@email.com)
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.8
*/
public interface ProxoolListenerIF {
/**
* Notify that a new connection pool has been registered. Gets called *after* the registered.
* @param connectionPoolDefinition the new definition.
* @param completeInfo the properties that could be used to create this definition.
*/
void onRegistration(ConnectionPoolDefinitionIF connectionPoolDefinition, Properties completeInfo);
/**
* Notify that a connection pool will be shutdown. Gets called just *before*
* the pool is shut down.
* @param alias the alias of the pool about to be shut down.
*/
void onShutdown(String alias);
}
/*
Revision history:
$Log: ProxoolListenerIF.java,v $
Revision 1.2 2003/03/03 11:11:58 billhorsman
fixed licence
Revision 1.1 2003/02/24 01:15:05 chr32
Init rev.
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ProxyConnection.java 0000644 0001750 0001750 00000035616 10730503125 030521 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.logicalcobwebs.concurrent.WriterPreferenceReadWriteLock;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.util.FastArrayList;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Date;
import java.util.Set;
import java.util.HashSet;
import java.util.List;
import java.text.DecimalFormat;
/**
* Manages a connection. This is wrapped up inside a...
*
* @version $Revision: 1.40 $, $Date: 2007/05/15 23:17:21 $
* @author bill
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.10
*/
public class ProxyConnection implements ProxyConnectionIF {
static final int STATUS_FORCE = -1;
private WriterPreferenceReadWriteLock statusReadWriteLock = new WriterPreferenceReadWriteLock();
private static final Log LOG = LogFactory.getLog(ProxyConnection.class);
private Connection connection;
private String delegateUrl;
private int mark;
private String reasonForMark;
private int status;
private long id;
private Date birthDate;
private long timeLastStartActive;
private long timeLastStopActive;
private ConnectionPool connectionPool;
private ConnectionPoolDefinitionIF definition;
private String requester;
private Set openStatements = new HashSet();
private DecimalFormat idFormat = new DecimalFormat("0000");
private List sqlCalls = new FastArrayList();
/**
* Whether we have invoked a method that requires us to reset
*/
private boolean needToReset = false;
/**
*
* @param connection the real connection that is used
* @param id unique ID
* @param delegateUrl
* @param connectionPool the pool it is a member of
* @param definition the definition that was used to build it (could possibly be different from
* the one held in the connectionPool)
* @param status {@link #STATUS_ACTIVE}, {@link #STATUS_AVAILABLE}, {@link #STATUS_FORCE}, {@link #STATUS_NULL}, or {@link #STATUS_OFFLINE}
* @throws SQLException
*/
protected ProxyConnection(Connection connection, long id, String delegateUrl, ConnectionPool connectionPool, ConnectionPoolDefinitionIF definition, int status) throws SQLException {
this.connection = connection;
this.delegateUrl = delegateUrl;
setId(id);
this.connectionPool = connectionPool;
this.definition = definition;
setBirthTime(System.currentTimeMillis());
this.status = status;
if (status == STATUS_ACTIVE) {
setTimeLastStartActive(System.currentTimeMillis());
}
// We only need to call this for the first connection we make. But it returns really
// quickly and we don't call it that often so we shouldn't worry.
connectionPool.initialiseConnectionResetter(connection);
if (connection == null) {
throw new SQLException("Unable to create new connection");
}
}
/**
* Whether the underlying connections are equal
* @param obj the object (probably another connection) that we
* are being compared to
* @return whether they are the same
*/
public boolean equals(Object obj) {
if (obj != null) {
if (obj instanceof ProxyConnection) {
return connection.hashCode() == ((ProxyConnection) obj).getConnection().hashCode();
} else if (obj instanceof Connection) {
return connection.hashCode() == obj.hashCode();
} else {
return super.equals(obj);
}
} else {
return false;
}
}
/**
* Whether this connection is available. (When you close the connection
* it doesn't really close, it just becomes available for others to use).
* @return true if the connection is not active
*/
public boolean isClosed() {
return (getStatus() != STATUS_ACTIVE);
}
/**
* The subclass should call this to indicate that a change has been made to
* the connection that might mean it needs to be reset (like setting autoCommit
* to false or something). We don't reset unless this has been called to avoid
* the overhead of unnecessary resetting.
*
* @param needToReset true if the connection might need resetting.
*/
protected void setNeedToReset(boolean needToReset) {
this.needToReset = needToReset;
}
/**
* The ConnectionPool that this connection belongs to
* @return connectionPool
*/
protected ConnectionPool getConnectionPool() {
return connectionPool;
}
/**
* Get the definition that was used to create this connection
* @return definition
*/
public ConnectionPoolDefinitionIF getDefinition() {
return definition;
}
/**
* By calling this we can keep track of any statements that are
* left open when this connection is returned to the pool.
* @param statement the statement that we have just opened/created.
* @see #registerClosedStatement
*/
protected void addOpenStatement(Statement statement) {
openStatements.add(statement);
}
/**
* @see ProxyConnectionIF#registerClosedStatement
*/
public void registerClosedStatement(Statement statement) {
if (openStatements.contains(statement)) {
openStatements.remove(statement);
} else {
connectionPool.getLog().warn(connectionPool.displayStatistics() + " - #" + getId() + " registered a statement as closed which wasn't known to be open. This could happen if you close a statement twice.");
}
}
/**
* Close the connection for real
* @throws java.sql.SQLException if anything goes wrong
*/
public void reallyClose() throws SQLException {
try {
connectionPool.registerRemovedConnection(getStatus());
// Clean up the actual connection
connection.close();
} catch (Throwable t) {
connectionPool.getLog().error("#" + idFormat.format(getId()) + " encountered errors during destruction: ", t);
}
}
/**
* @see ProxyConnectionIF#isReallyClosed
*/
public boolean isReallyClosed() throws SQLException {
if (connection == null) {
return true;
} else {
return connection.isClosed();
}
}
/**
* @see ProxyConnectionIF#close
*/
public void close() throws SQLException {
try {
boolean removed = false;
if (isMarkedForExpiry()) {
if (connectionPool.getLog().isDebugEnabled()) {
connectionPool.getLog().debug("Closing connection quickly (without reset) because it's marked for expiry anyway");
}
} else {
// Close any open statements, as specified in JDBC
Statement[] statements = (Statement[]) openStatements.toArray(new Statement[openStatements.size()]);
for (int j = 0; j < statements.length; j++) {
Statement statement = statements[j];
statement.close();
if (connectionPool.getLog().isDebugEnabled()) {
connectionPool.getLog().debug("Closing statement " + Integer.toHexString(statement.hashCode()) + " (belonging to connection " + getId() + ") automatically");
}
}
openStatements.clear();
if (needToReset) {
// This call should be as quick as possible. Should we consider only
// calling it if values have changed? The trouble with that is that it
// means keeping track when they change and that might be even
// slower
if (!connectionPool.resetConnection(connection, "#" + getId())) {
connectionPool.removeProxyConnection(this, ConnectionListenerIF.RESET_FAIL, "it couldn't be reset", true, true);
removed = true;
}
needToReset = false;
}
}
// If we removed it above then putting it back will only cause a confusing log event later when
// it is unable to be changed from ACTIVE to AVAILABLE.
if (!removed) {
connectionPool.putConnection(this);
}
} catch (Throwable t) {
connectionPool.getLog().error("#" + idFormat.format(getId()) + " encountered errors during closure: ", t);
}
}
/**
* This gets called /just/ before a connection is served. You can use it to reset some of the attributes.
* The lifecycle is: {@link #open()} then {@link #close()}
*/
protected void open() {
sqlCalls.clear();
}
public int getMark() {
return mark;
}
public int getStatus() {
return status;
}
/**
* @see ProxyConnectionIF#setStatus(int)
*/
public boolean setStatus(int newStatus) {
return setStatus(STATUS_FORCE, newStatus);
}
/**
* @see ProxyConnectionIF#setStatus(int, int)
*/
public boolean setStatus(int oldStatus, int newStatus) {
boolean success = false;
try {
statusReadWriteLock.writeLock().acquire();
connectionPool.acquireConnectionStatusWriteLock();
if (this.status == oldStatus || oldStatus == STATUS_FORCE) {
connectionPool.changeStatus(this.status, newStatus);
this.status = newStatus;
success = true;
if (newStatus == oldStatus) {
LOG.warn("Unexpected attempt to change status from " + oldStatus + " to " + newStatus
+ ". Why would you want to do that?");
} else if (newStatus == STATUS_ACTIVE) {
setTimeLastStartActive(System.currentTimeMillis());
} else if (oldStatus == STATUS_ACTIVE) {
setTimeLastStopActive(System.currentTimeMillis());
}
}
} catch (InterruptedException e) {
LOG.error("Unable to acquire write lock for status");
} finally {
connectionPool.releaseConnectionStatusWriteLock();
statusReadWriteLock.writeLock().release();
}
return success;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
/**
* @see ConnectionInfoIF#getBirthTime
*/
public long getBirthTime() {
return birthDate.getTime();
}
/**
* @see ConnectionInfoIF#getBirthDate
*/
public Date getBirthDate() {
return birthDate;
}
/**
* @see ConnectionInfoIF#getAge
*/
public long getAge() {
return System.currentTimeMillis() - getBirthTime();
}
/**
* @see ConnectionInfoIF#getBirthTime
*/
public void setBirthTime(long birthTime) {
birthDate = new Date(birthTime);
}
/**
* @see ConnectionInfoIF#getTimeLastStartActive
*/
public long getTimeLastStartActive() {
return timeLastStartActive;
}
/**
* @see ConnectionInfoIF#getTimeLastStartActive
*/
public void setTimeLastStartActive(long timeLastStartActive) {
this.timeLastStartActive = timeLastStartActive;
setTimeLastStopActive(0);
}
/**
* @see ConnectionInfoIF#getTimeLastStopActive
*/
public long getTimeLastStopActive() {
return timeLastStopActive;
}
/**
* @see ConnectionInfoIF#getTimeLastStopActive
*/
public void setTimeLastStopActive(long timeLastStopActive) {
this.timeLastStopActive = timeLastStopActive;
}
/**
* @see ConnectionInfoIF#getRequester
*/
public String getRequester() {
return requester;
}
/**
* @see ConnectionInfoIF#getRequester
*/
public void setRequester(String requester) {
this.requester = requester;
}
/**
* @see ProxyConnectionIF#isNull
*/
public boolean isNull() {
return getStatus() == STATUS_NULL;
}
/**
* @see ProxyConnectionIF#isAvailable
*/
public boolean isAvailable() {
return getStatus() == STATUS_AVAILABLE;
}
/**
* @see ProxyConnectionIF#isActive
*/
public boolean isActive() {
return getStatus() == STATUS_ACTIVE;
}
/**
* @see ProxyConnectionIF#isOffline
*/
public boolean isOffline() {
return getStatus() == STATUS_OFFLINE;
}
/**
* @see ProxyConnectionIF#markForExpiry
*/
public void markForExpiry(String reason) {
mark = MARK_FOR_EXPIRY;
reasonForMark = reason;
}
/**
* @see ProxyConnectionIF#isMarkedForExpiry
*/
public boolean isMarkedForExpiry() {
return getMark() == MARK_FOR_EXPIRY;
}
/**
* @see ProxyConnectionIF#getReasonForMark
*/
public String getReasonForMark() {
return reasonForMark;
}
/**
* @see ProxyConnectionIF#getConnection
*/
public Connection getConnection() {
return connection;
}
/**
* @see Object#toString
*/
public String toString() {
return getId() + " is " + ConnectionPool.getStatusDescription(getStatus());
}
/**
* @see ConnectionInfoIF#getDelegateUrl
*/
public String getDelegateUrl() {
return delegateUrl;
}
/**
* @see ConnectionInfoIF#getProxyHashcode
*/
public String getProxyHashcode() {
return Integer.toHexString(hashCode());
}
/**
* @see ConnectionInfoIF#getDelegateHashcode
*/
public String getDelegateHashcode() {
if (connection != null) {
return Integer.toHexString(connection.hashCode());
} else {
return null;
}
}
/**
* Compares using {@link #getId()}
* @param o must be another {@link ConnectionInfoIF} implementation
* @return the comparison
* @see Comparable#compareTo(Object)
*/
public int compareTo(Object o) {
return new Long(((ConnectionInfoIF) o).getId()).compareTo(new Long(getId()));
}
public String[] getSqlCalls() {
return (String[]) sqlCalls.toArray(new String[0]);
}
public String getLastSqlCall() {
if (sqlCalls != null && sqlCalls.size() > 0) {
return (String) sqlCalls.get(sqlCalls.size() - 1);
} else {
return null;
}
}
public int getReasonCode() {
return 0; //To change body of implemented methods use File | Settings | File Templates.
}
public void addSqlCall(String sqlCall) {
this.sqlCalls.add(sqlCall);
}
}
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ProxyConnectionIF.java 0000644 0001750 0001750 00000013406 10730503125 030731 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
/**
* Contains most of the functionality that we require to manipilate the
* connection. The subclass of this defines how we delegate to the
* real connection.
* @version $Revision: 1.8 $, $Date: 2007/01/25 23:38:24 $
* @author bill
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.7
*/
public interface ProxyConnectionIF extends ConnectionInfoIF {
/**
* Changes the status and lets the ConnectionPool know so that it
* can keep count of how many connections are at each status.
* This method obtains a write lock.
* @param oldStatus the expected existing status. if the existing
* status is not this value then no change is made and false is returned.
* @param newStatus the status to change to
* @return true if status changed successfully, or false if no change made
* (because of unexpected existing status).
*/
boolean setStatus(int oldStatus, int newStatus);
/**
* Forces the new status regardless of the old state
* @param newStatus the status to change to
* @return true if status changed successfully, or false if no change made (should
* always return true)
* @see #setStatus(int, int)
*/
boolean setStatus(int newStatus);
/**
* Mark this connection for expiry (destruction) as soon as it stops
* being active.
* @param reason why we are marking this connection
* @see #isMarkedForExpiry
*/
void markForExpiry(String reason);
/**
* Whether this connection is due for expiry
* @return true if it is due for expiry
* @see #markForExpiry
*/
boolean isMarkedForExpiry();
/**
* Why this connection is marked (for instance, if a thread has
* marked it for expiry then it's nice to know why)
* @return reasonForMark
*/
String getReasonForMark();
/**
* The real, delegate connection that we are using
* @return connection
*/
Connection getConnection();
/**
* @return true if the status is null
*/
boolean isNull();
/**
* @return true if the status is available
*/
boolean isAvailable();
/**
* @return true if the status is active
*/
boolean isActive();
/**
* @return true if the status is offline
*/
boolean isOffline();
/**
* Really close the connection, as opposed to just putting it back
* in the pool.
*/
void reallyClose() throws SQLException;
/**
* @see ConnectionInfoIF#getRequester
*/
void setRequester(String requester);
/**
* Doesn't really close the connection, just puts it back in the pool. And tries to
* reset all the methods that need resetting.
* @see Connection#close
*/
void close() throws SQLException;
/**
* Notify that a statement has been closed and won't need closing
* when the connection is returned to the poo.
* @param statement the statement that has just been closed
*/
void registerClosedStatement(Statement statement);
/**
* Find out if the delegated connection is close. Just calling isClosed() on the
* proxied connection will only indicate whether it is in the pool or not.
* @return true if the connection is really closed, or if the connection is null
* @throws java.sql.SQLException if anything went wrong
*/
boolean isReallyClosed() throws SQLException;
ConnectionPoolDefinitionIF getDefinition();
/**
* Get the most recent of all the {@link #getSqlCalls()}
* @return the SQL (could be a batch of SQLs)
*/
String getLastSqlCall();
/**
* Get the reason why this connection is {@link #getMark() marked}
* @return {@link org.logicalcobwebs.proxool.ConnectionListenerIF#MAXIMUM_ACTIVE_TIME_EXPIRED},
* {@link org.logicalcobwebs.proxool.ConnectionListenerIF#HOUSE_KEEPER_TEST_FAIL},
* {@link org.logicalcobwebs.proxool.ConnectionListenerIF#FATAL_SQL_EXCEPTION_DETECTED},
* {@link org.logicalcobwebs.proxool.ConnectionListenerIF#MANUAL_EXPIRY},
* {@link org.logicalcobwebs.proxool.ConnectionListenerIF#MAXIMUM_CONNECTION_LIFETIME_EXCEEDED},
* {@link org.logicalcobwebs.proxool.ConnectionListenerIF#RESET_FAIL},
* {@link org.logicalcobwebs.proxool.ConnectionListenerIF#SHUTDOWN}, or
* {@link org.logicalcobwebs.proxool.ConnectionListenerIF#VALIDATION_FAIL}
*/
int getReasonCode();
}
/*
Revision history:
$Log: ProxyConnectionIF.java,v $
Revision 1.8 2007/01/25 23:38:24 billhorsman
Scrapped onAboutToDie and altered onDeath signature instead. Now includes reasonCode (see ConnectionListenerIF)
Revision 1.7 2005/10/07 08:18:24 billhorsman
New sqlCalls gives list of SQL calls rather than just he most recent (for when a connection makes more than one call before being returned to the pool)
Revision 1.6 2005/09/26 10:01:31 billhorsman
Added lastSqlCall when trace is on.
Revision 1.5 2005/05/04 16:24:13 billhorsman
include a reference to the definition so we can spot it changing.
Revision 1.4 2003/03/10 15:26:49 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.3 2003/03/03 11:11:58 billhorsman
fixed licence
Revision 1.2 2003/02/26 16:05:53 billhorsman
widespread changes caused by refactoring the way we
update and redefine pool definitions.
Revision 1.1 2003/01/27 18:26:39 billhorsman
refactoring of ProxyConnection and ProxyStatement to
make it easier to write JDK 1.2 patch
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ProxyDatabaseMetaData.java 0000644 0001750 0001750 00000015455 10730503124 031525 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.cglib.proxy.MethodInterceptor;
import org.logicalcobwebs.cglib.proxy.MethodProxy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
/**
* Delegates to a normal Coonection for everything but the close()
* method (when it puts itself back into the pool instead).
* @version $Revision: 1.9 $, $Date: 2006/01/18 14:40:02 $
* @author billhorsman
* @author $Author: billhorsman $ (current maintainer)
*/
class ProxyDatabaseMetaData implements MethodInterceptor {
private static final Log LOG = LogFactory.getLog(ProxyDatabaseMetaData.class);
private static final String GET_CONNECTION_METHOD = "getConnection";
private static final String EQUALS_METHOD = "equals";
private static final String FINALIZE_METHOD = "finalize";
private DatabaseMetaData databaseMetaData;
private Connection wrappedConnection;
/**
* @param databaseMetaData the meta data we use to delegate all calls to (except getConnection())
* @param wrappedConnection the connection we return if asked for the connection
*/
public ProxyDatabaseMetaData(DatabaseMetaData databaseMetaData, Connection wrappedConnection) {
this.databaseMetaData = databaseMetaData;
this.wrappedConnection = wrappedConnection;
}
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object result = null;
int argCount = args != null ? args.length : 0;
try {
if (method.getName().equals(GET_CONNECTION_METHOD)) {
result = getConnection();
} else if (method.getName().equals(EQUALS_METHOD) && argCount == 1) {
result = new Boolean(equals(args[0]));
} else if (method.getName().equals(FINALIZE_METHOD)) {
super.finalize();
} else {
result = method.invoke(getDatabaseMetaData(), args);
}
} catch (InvocationTargetException e) {
throw e.getTargetException();
} catch (Exception e) {
LOG.error("Unexpected invocation exception", e);
throw new RuntimeException("Unexpected invocation exception: "
+ e.getMessage());
}
return result;
}
/**
* Whether the underlying databaseMetaData are equal
* @param obj the object (probably another databaseMetaData) that we
* are being compared to
* @return whether they are the same
*/
public boolean equals(Object obj) {
return databaseMetaData.hashCode() == obj.hashCode();
}
/**
* We don't want to ask the DatabaseMetaData object for the
* connection or we will get the delegate instead of the Proxool
* one.
* @see DatabaseMetaData#getConnection
*/
public Connection getConnection() {
return wrappedConnection;
}
/**
* Get the DatabaseMetaData from the connection
* @return databaseMetaData
*/
protected DatabaseMetaData getDatabaseMetaData() {
return databaseMetaData;
}
/**
* @see Object#toString
*/
public String toString() {
return databaseMetaData.toString();
}
}
/*
Revision history:
$Log: ProxyDatabaseMetaData.java,v $
Revision 1.9 2006/01/18 14:40:02 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.8 2004/06/02 20:50:47 billhorsman
Dropped obsolete InvocationHandler reference and injectable interface stuff.
Revision 1.7 2004/03/23 21:19:45 billhorsman
Added disposable wrapper to proxied connection. And made proxied objects implement delegate interfaces too.
Revision 1.6 2003/12/12 19:29:47 billhorsman
Now uses Cglib 2.0
Revision 1.5 2003/09/10 22:21:04 chr32
Removing > jdk 1.2 dependencies.
Revision 1.4 2003/03/03 11:11:58 billhorsman
fixed licence
Revision 1.3 2003/02/06 17:41:04 billhorsman
now uses imported logging
Revision 1.2 2003/01/31 16:53:18 billhorsman
checkstyle
Revision 1.1 2003/01/31 14:33:18 billhorsman
fix for DatabaseMetaData
Revision 1.21 2003/01/27 18:26:38 billhorsman
refactoring of ProxyConnection and ProxyStatement to
make it easier to write JDK 1.2 patch
Revision 1.20 2002/12/19 00:08:36 billhorsman
automatic closure of statements when a connection is closed
Revision 1.19 2002/12/17 17:15:39 billhorsman
Better synchronization of status stuff
Revision 1.18 2002/12/03 12:24:00 billhorsman
fixed fatal sql exception
Revision 1.17 2002/11/12 20:24:12 billhorsman
checkstyle
Revision 1.16 2002/11/12 20:18:23 billhorsman
Made connection resetter a bit more friendly. Now, if it encounters any problems
during reset then that connection is thrown away. This is going to cause you
problems if you always close connections in an unstable state (e.g. with transactions
open. But then again, it's better to know about that as soon as possible, right?
Revision 1.15 2002/11/07 18:56:22 billhorsman
fixed NullPointerException introduced yesterday on isClose() method
Revision 1.14 2002/11/07 12:38:04 billhorsman
performance improvement - only reset when it might be necessary
Revision 1.13 2002/11/06 20:26:49 billhorsman
improved doc, added connection resetting, and made
isClosed() work correctly
Revision 1.12 2002/11/02 13:57:33 billhorsman
checkstyle
Revision 1.11 2002/10/30 21:25:09 billhorsman
move createStatement into ProxyFactory
Revision 1.10 2002/10/30 21:19:17 billhorsman
make use of ProxyFactory
Revision 1.9 2002/10/28 19:51:34 billhorsman
Fixed NullPointerException when calling connection.createProxyStatement()
Revision 1.8 2002/10/28 19:28:25 billhorsman
checkstyle
Revision 1.7 2002/10/28 08:20:23 billhorsman
draft sql dump stuff
Revision 1.6 2002/10/25 15:59:32 billhorsman
made non-public where possible
Revision 1.5 2002/10/24 18:15:09 billhorsman
removed unnecessary debug
Revision 1.4 2002/10/17 15:29:18 billhorsman
fixes so that equals() works
Revision 1.3 2002/09/19 10:33:57 billhorsman
added ProxyConnection#toString
Revision 1.2 2002/09/18 13:48:56 billhorsman
checkstyle and doc
Revision 1.1.1.1 2002/09/13 08:13:30 billhorsman
new
Revision 1.10 2002/08/24 19:57:15 billhorsman
checkstyle changes
Revision 1.9 2002/08/24 19:42:26 billhorsman
new proxy stuff to work with JDK 1.4
Revision 1.6 2002/07/02 11:19:08 billhorsman
layout code and imports
Revision 1.5 2002/06/28 11:19:47 billhorsman
improved doc
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ProxyFactory.java 0000644 0001750 0001750 00000036243 10730503125 030026 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.logicalcobwebs.cglib.proxy.Enhancer;
import org.logicalcobwebs.cglib.proxy.Factory;
import org.logicalcobwebs.cglib.proxy.Callback;
import org.logicalcobwebs.cglib.core.NamingPolicy;
import org.logicalcobwebs.cglib.core.Predicate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Statement;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.util.HashSet;
import java.util.Set;
import java.util.Map;
import java.util.HashMap;
import java.lang.reflect.Modifier;
/**
* A central place to build proxy objects. It will also provide the original
* object given a proxy.
* @author Bill Horsman (bill@logicalcobwebs.co.uk)
* @author $Author: billhorsman $ (current maintainer)
* @version $Revision: 1.33 $, $Date: 2006/04/09 21:08:43 $
* @since Proxool 0.5
*/
class ProxyFactory {
private static final Log LOG = LogFactory.getLog(ProxyFactory.class);
private static Map interfaceMap = new HashMap();
/**
* This naming policy stops conflicts with other Cglib instances that are running
* (Even ones in different packages). Without using our own naming policy we end
* up with exceptions like:
*
* java.lang.LinkageError: duplicate class definition:
* $java/lang/Object$$FastClassByCGLIB$$3f697993
*
*/
private static NamingPolicy NAMING_POLICY = new NamingPolicy() {
public String getClassName(String prefix, String source, Object key, Predicate names) {
StringBuffer sb = new StringBuffer();
sb.append(
(prefix != null) ?
(
prefix.startsWith("java") ?
"$" + prefix : prefix
)
: "net.sf.cglib.empty.Object"
);
sb.append("$$");
sb.append(source.substring(source.lastIndexOf('.') + 1));
sb.append("ByProxool$$");
sb.append(Integer.toHexString(key.hashCode()));
String base = sb.toString();
String attempt = base;
int index = 2;
while (names.evaluate(attempt)) {
attempt = base + "_" + index++;
}
return attempt;
}
};
/**
* Wraps up a proxyConnection inside a {@link WrappedConnection} and then proxies it as a
* simple {@link Connection}. You should call this immediately before the connection is served
* to the user. The WrappedConnection is disposable (it is thrown away when the connection
* is returned to the pool).
* @param proxyConnection the pooled connection we are wrapping up
* @return the Connection for use
*/
protected static Connection getWrappedConnection(ProxyConnection proxyConnection) {
return (Connection) getProxy(proxyConnection.getConnection(), new WrappedConnection(proxyConnection), proxyConnection.getDefinition());
}
/**
* Proxies a statement inside a {@link ProxyStatement}.
* @param delegate the real statement
* @param connectionPool the pool it belongs to
* @param proxyConnection the connection it was built from
* @param sqlStatement Can be null?
* @return the proxied statement
*/
protected static Statement getStatement(Statement delegate, ConnectionPool connectionPool, ProxyConnectionIF proxyConnection, String sqlStatement) {
return (Statement) getProxy(delegate, new ProxyStatement(delegate, connectionPool, proxyConnection, sqlStatement), proxyConnection.getDefinition());
}
/**
* Create a new DatabaseMetaData from a connection
* @param databaseMetaData the meta data we use to delegate all calls to (except getConnection())
* @param wrappedConnection the connection we return if asked for the connection
* @return databaseMetaData
*/
protected static DatabaseMetaData getDatabaseMetaData(DatabaseMetaData databaseMetaData, Connection wrappedConnection) {
return (DatabaseMetaData) getProxy(databaseMetaData, new ProxyDatabaseMetaData(databaseMetaData, wrappedConnection), null);
}
private static Object getProxy(Object delegate, Callback callback, ConnectionPoolDefinitionIF def) {
Enhancer e = new Enhancer();
e.setNamingPolicy(NAMING_POLICY);
e.setInterfaces(getInterfaces(delegate.getClass(), def));
e.setCallback(callback);
e.setClassLoader(ProxyFactory.class.getClassLoader());
return e.create();
}
/**
* Gets the real Statement that we got from the delegate driver. This is no longer
* necessary and only provided for backwards compatability.
* @param statement proxy statement
* @return delegate statement
* @see ProxoolFacade#getDelegateStatement(java.sql.Statement)
*/
protected static Statement getDelegateStatement(Statement statement) {
Statement ds = statement;
ProxyStatement ps = (ProxyStatement) ((Factory)statement).getCallback(0);
ds = ps.getDelegateStatement();
return ds;
}
/**
* Gets the real Connection that we got from the delegate driver. This is no longer
* necessary and only provided for backwards compatability.
* @param connection proxy connection
* @return deletgate connection
* @see ProxoolFacade#getDelegateConnection(java.sql.Connection)
*/
protected static Connection getDelegateConnection(Connection connection) {
WrappedConnection wc = (WrappedConnection) ((Factory)connection).getCallback(0);
return wc.getProxyConnection().getConnection();
}
/**
* Get all the interfaces that a class implements. Drills down into super interfaces too
* and super classes too.
* The results are cached so it's very fast second time round.
* @param clazz the class to examine.
* @return an array of classes (all interfaces) that this class implements.
*/
private static Class[] getInterfaces(Class clazz, ConnectionPoolDefinitionIF cpd) {
Class[] interfaceArray = (Class[]) interfaceMap.get(clazz);
if (interfaceArray == null) {
Set interfaces = new HashSet();
traverseInterfacesRecursively(interfaces, clazz);
if (cpd != null) {
// Work out which interface we should be injecting (if it has been configured). Make sure
// we check CallableStatement then PreparedStatement then Statement or all three will get
// caught by Statement
if (Connection.class.isAssignableFrom(clazz)) {
Class injectableClass = cpd.getInjectableConnectionInterface();
// Inject it if it was configured.
if (injectableClass != null) {
interfaces.add(injectableClass);
if (LOG.isDebugEnabled()) {
LOG.debug("Injecting " + injectableClass + " into " + clazz);
}
}
}
if (CallableStatement.class.isAssignableFrom(clazz)) {
if (LOG.isDebugEnabled()) {
LOG.debug("Getting injectableCallableStatementInterface");
}
Class injectableClass = cpd.getInjectableCallableStatementInterface();
// Inject it if it was configured.
if (injectableClass != null) {
interfaces.add(injectableClass);
if (LOG.isDebugEnabled()) {
LOG.debug("Injecting " + injectableClass + " into " + clazz);
}
}
}
if (PreparedStatement.class.isAssignableFrom(clazz)) {
Class injectableClass = cpd.getInjectablePreparedStatementInterface();
// Inject it if it was configured.
if (injectableClass != null) {
interfaces.add(injectableClass);
if (LOG.isDebugEnabled()) {
LOG.debug("Injecting " + injectableClass + " into " + clazz);
}
}
}
if (Statement.class.isAssignableFrom(clazz)) {
Class injectableClass = cpd.getInjectableStatementInterface();
// Inject it if it was configured.
if (injectableClass != null) {
interfaces.add(injectableClass);
if (LOG.isDebugEnabled()) {
LOG.debug("Injecting " + injectableClass + " into " + clazz);
}
}
}
}
interfaceArray = (Class[]) interfaces.toArray(new Class[interfaces.size()]);
if (LOG.isDebugEnabled()) {
for (int i = 0; i < interfaceArray.length; i++) {
Class aClass = interfaceArray[i];
LOG.debug("Implementing " + aClass);
}
}
interfaceMap.put(clazz, interfaceArray);
/*
} else {
if (LOG.isDebugEnabled()) {
LOG.debug("Reusing " + interfaceArray.length + " interfaces already looked up for " + clazz);
}
*/
}
return interfaceArray;
}
/**
* Recursively looks at all interfaces for a class. Also looks at interfaces implemented
* by the super class (and its super class, etc.) Quite a lot of processing involved
* so you shouldn't call it too often.
* @param interfaces this set is populated with all interfaceMap it finds
* @param clazz the base class to analyze
*/
private static void traverseInterfacesRecursively(Set interfaces, Class clazz) {
// Check for circular reference (avoid endless recursion)
if (interfaces.contains(clazz)) {
// Skip it, we've already been here.
/*
if (LOG.isDebugEnabled()) {
LOG.debug("Skipping " + clazz + " because we've already traversed it");
}
*/
} else {
/*
if (LOG.isDebugEnabled()) {
LOG.debug("Analyzing " + clazz);
}
*/
Class[] interfaceArray = clazz.getInterfaces();
for (int i = 0; i < interfaceArray.length; i++) {
/*
if (LOG.isDebugEnabled()) {
LOG.debug("Adding " + interfaceArray[i]);
}
*/
traverseInterfacesRecursively(interfaces, interfaceArray[i]);
// We're only interested in public interfaces. In fact, including
// non-public interfaces will give IllegalAccessExceptions.
if (Modifier.isPublic(interfaceArray[i].getModifiers())) {
interfaces.add(interfaceArray[i]);
}
}
Class superClazz = clazz.getSuperclass();
if (superClazz != null) {
traverseInterfacesRecursively(interfaces, superClazz);
}
/*
if (LOG.isDebugEnabled()) {
LOG.debug("Found " + interfaceArray.length + " interfaceMap for " + clazz);
}
*/
}
}
/**
* Get the WrappedConnection behind this proxy connection.
* @param connection the connection that was served
* @return the wrapped connection or null if it couldn't be found
*/
public static WrappedConnection getWrappedConnection(Connection connection) {
return (WrappedConnection) ((Factory)connection).getCallback(0);
}
}
/*
Revision history:
$Log: ProxyFactory.java,v $
Revision 1.33 2006/04/09 21:08:43 billhorsman
Use our own naming policy for Cglib to avoid duplicate class definition exceptions.
Revision 1.32 2006/01/18 14:40:02 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.31 2005/09/26 09:59:22 billhorsman
Explicitly use the ProxyFactory class loader when using Cglib's Enhancer to avoid class loading issues.
Revision 1.30 2005/05/04 16:31:41 billhorsman
Use the definition referenced by the proxy connection rather than the pool instead.
Revision 1.29 2004/07/27 21:44:15 billhorsman
Remove insane amount of debug logging.
Revision 1.28 2004/06/17 21:58:36 billhorsman
Injectable interface fixes.
Revision 1.27 2004/06/02 20:50:47 billhorsman
Dropped obsolete InvocationHandler reference and injectable interface stuff.
Revision 1.26 2004/03/23 21:19:45 billhorsman
Added disposable wrapper to proxied connection. And made proxied objects implement delegate interfaces too.
Revision 1.25 2003/12/12 19:29:47 billhorsman
Now uses Cglib 2.0
Revision 1.24 2003/09/30 18:39:08 billhorsman
New test-before-use, test-after-use and fatal-sql-exception-wrapper-class properties.
Revision 1.23 2003/09/10 22:21:04 chr32
Removing > jdk 1.2 dependencies.
Revision 1.22 2003/09/07 22:11:31 billhorsman
Remove very persistent debug message
Revision 1.21 2003/08/27 18:03:20 billhorsman
added new getDelegateConnection() method
Revision 1.20 2003/03/11 14:51:54 billhorsman
more concurrency fixes relating to snapshots
Revision 1.19 2003/03/10 23:43:13 billhorsman
reapplied checkstyle that i'd inadvertently let
IntelliJ change...
Revision 1.18 2003/03/10 15:26:49 billhorsman
refactoringn of concurrency stuff (and some import
optimisation)
Revision 1.17 2003/03/05 18:42:33 billhorsman
big refactor of prototyping and house keeping to
drastically reduce the number of threads when using
many pools
Revision 1.16 2003/03/03 11:11:58 billhorsman
fixed licence
Revision 1.15 2003/02/19 15:14:32 billhorsman
fixed copyright (copy and paste error,
not copyright change)
Revision 1.14 2003/02/12 12:28:27 billhorsman
added url, proxyHashcode and delegateHashcode to
ConnectionInfoIF
Revision 1.13 2003/02/06 17:41:04 billhorsman
now uses imported logging
Revision 1.12 2003/01/31 14:33:18 billhorsman
fix for DatabaseMetaData
Revision 1.11 2003/01/27 18:26:39 billhorsman
refactoring of ProxyConnection and ProxyStatement to
make it easier to write JDK 1.2 patch
Revision 1.10 2002/12/16 11:15:19 billhorsman
fixed getDelegateStatement
Revision 1.9 2002/12/16 10:57:47 billhorsman
add getDelegateStatement to allow access to the
delegate JDBC driver's Statement
Revision 1.8 2002/12/12 10:48:25 billhorsman
checkstyle
Revision 1.7 2002/12/08 22:17:35 billhorsman
debug for proxying statement interfaces
Revision 1.6 2002/12/06 15:57:08 billhorsman
fix for proxied statement where Statement interface is not directly
implemented.
Revision 1.5 2002/12/03 12:24:00 billhorsman
fixed fatal sql exception
Revision 1.4 2002/11/09 15:56:52 billhorsman
fix doc
Revision 1.3 2002/11/02 14:22:15 billhorsman
Documentation
Revision 1.2 2002/10/30 21:25:08 billhorsman
move createStatement into ProxyFactory
Revision 1.1 2002/10/30 21:19:16 billhorsman
make use of ProxyFactory
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ProxyStatement.java 0000644 0001750 0001750 00000025741 10730503125 030364 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.cglib.proxy.MethodInterceptor;
import org.logicalcobwebs.cglib.proxy.MethodProxy;
import org.logicalcobwebs.cglib.proxy.InvocationHandler;
import org.logicalcobwebs.proxool.proxy.InvokerFacade;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Statement;
import java.sql.Connection;
/**
* Delegates to Statement for all calls. But also, for all execute methods, it
* checks the SQLException and compares it to the fatalSqlException list in the
* ConnectionPoolDefinition. If it detects a fatal exception it will destroy the
* Connection so that it isn't used again.
* @version $Revision: 1.32 $, $Date: 2006/03/03 09:58:26 $
* @author billhorsman
* @author $Author: billhorsman $ (current maintainer)
*/
class ProxyStatement extends AbstractProxyStatement implements MethodInterceptor {
private static final Log LOG = LogFactory.getLog(ProxyStatement.class);
private static final String EXECUTE_FRAGMENT = "execute";
private static final String EXECUTE_BATCH_METHOD = "executeBatch";
private static final String ADD_BATCH_METHOD = "addBatch";
private static final String EQUALS_METHOD = "equals";
private static final String CLOSE_METHOD = "close";
private static final String GET_CONNECTION_METHOD = "getConnection";
private static final String FINALIZE_METHOD = "finalize";
private static final String SET_NULL_METHOD = "setNull";
private static final String SET_PREFIX = "set";
public ProxyStatement(Statement statement, ConnectionPool connectionPool, ProxyConnectionIF proxyConnection, String sqlStatement) {
super(statement, connectionPool, proxyConnection, sqlStatement);
}
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
return invoke(proxy, method, args);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
long startTime = System.currentTimeMillis();
final int argCount = args != null ? args.length : 0;
Method concreteMethod = InvokerFacade.getConcreteMethod(getStatement().getClass(), method);
// This gets called /before/ the method has run
if (concreteMethod.getName().equals(ADD_BATCH_METHOD)) {
// If we have just added a batch call then we need to update the sql log
if (argCount > 0 && args[0] instanceof String) {
setSqlStatementIfNull((String) args[0]);
}
appendToSqlLog();
} else if (concreteMethod.getName().equals(EXECUTE_BATCH_METHOD)) {
// executing a batch should do a trace
startExecute();
} else if (concreteMethod.getName().startsWith(EXECUTE_FRAGMENT)) {
// executing should update the log and do a trace
if (argCount > 0 && args[0] instanceof String) {
setSqlStatementIfNull((String) args[0]);
}
appendToSqlLog();
startExecute();
}
// We need to remember an exceptions that get thrown so that we can optionally
// pass them to the onExecute() call below
Exception exception = null;
try {
if (concreteMethod.getName().equals(EQUALS_METHOD) && argCount == 1) {
result = (equals(args[0])) ? Boolean.TRUE : Boolean.FALSE;
} else if (concreteMethod.getName().equals(CLOSE_METHOD) && argCount == 0) {
close();
} else if (concreteMethod.getName().equals(GET_CONNECTION_METHOD) && argCount == 0) {
result = getConnection();
} else if (concreteMethod.getName().equals(FINALIZE_METHOD) && argCount == 0) {
finalize();
} else {
try {
result = concreteMethod.invoke(getStatement(), args);
} catch (IllegalAccessException e) {
// This is probably because we are trying to access a non-public concrete class. But don't worry,
// we can always use the proxy supplied method. This will only fail if we try to use an injectable
// method on a method in a class that isn't public and for a method that isn't declared in an interface -
// but if that is the case then that method is inaccessible by any means (even by bypassing Proxool and
// using the vendor's driver directly).
LOG.debug("Ignoring IllegalAccessException whilst invoking the " + concreteMethod + " concrete method and trying the " + method + " method directly.");
// By overriding the method cached in the InvokerFacade we ensure that we only log this message once, and
// we speed up subsequent usages by not calling the method that fails first.
InvokerFacade.overrideConcreteMethod(getStatement().getClass(), method, method);
result = method.invoke(getStatement(), args);
}
}
// We only dump sql calls if we are in verbose mode and debug is enabled
if (isTrace()) {
try {
// What sort of method is it
if (concreteMethod.getName().equals(SET_NULL_METHOD) && argCount > 0 && args[0] instanceof Integer) {
int index = ((Integer) args[0]).intValue();
putParameter(index, null);
} else if (concreteMethod.getName().startsWith(SET_PREFIX) && argCount > 1 && args[0] instanceof Integer) {
int index = ((Integer) args[0]).intValue();
putParameter(index, args[1]);
}
} catch (Exception e) {
// We don't want an error during dump screwing up the transaction
LOG.error("Ignoring error during dump", e);
}
}
} catch (InvocationTargetException e) {
if (e.getTargetException() instanceof Exception) {
exception = (Exception) e.getTargetException();
} else {
exception = e;
}
if (testException(e.getTargetException())) {
// This is really a fatal one
FatalSqlExceptionHelper.throwFatalSQLException(getConnectionPool().getDefinition().getFatalSqlExceptionWrapper(), e.getTargetException());
}
throw e.getTargetException();
} catch (Exception e) {
exception = e;
if (testException(e)) {
// This is really a fatal one
FatalSqlExceptionHelper.throwFatalSQLException(getConnectionPool().getDefinition().getFatalSqlExceptionWrapper(), e);
}
throw e;
} finally {
// This gets called /after/ the method has run
if (concreteMethod.getName().equals(EXECUTE_BATCH_METHOD) || concreteMethod.getName().startsWith(EXECUTE_FRAGMENT)) {
trace(startTime, exception);
}
}
return result;
}
}
/*
Revision history:
$Log: ProxyStatement.java,v $
Revision 1.32 2006/03/03 09:58:26 billhorsman
Fix for statement.getConnection(). See bug 1149834.
Revision 1.31 2006/01/18 14:40:02 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.30 2006/01/16 23:09:28 billhorsman
Call concrete finalize() method
Revision 1.29 2005/10/07 08:15:00 billhorsman
Update sqlCalls /before/ we execute so that we can see what slow calls are doing before they finish.
Revision 1.28 2004/07/13 21:06:18 billhorsman
Fix problem using injectable interfaces on methods that are declared in non-public classes.
Revision 1.27 2004/06/17 21:56:53 billhorsman
Use MethodMapper for concrete methods.
Revision 1.26 2004/06/02 20:48:14 billhorsman
Dropped obsolete InvocationHandler reference.
Revision 1.25 2003/12/12 19:29:47 billhorsman
Now uses Cglib 2.0
Revision 1.24 2003/10/19 09:50:33 billhorsman
Drill down into InvocationTargetException during execution debug.
Revision 1.23 2003/10/18 20:44:48 billhorsman
Better SQL logging (embed parameter values within SQL call) and works properly with batched statements now.
Revision 1.22 2003/09/30 18:39:08 billhorsman
New test-before-use, test-after-use and fatal-sql-exception-wrapper-class properties.
Revision 1.21 2003/09/29 17:48:49 billhorsman
New fatal-sql-exception-wrapper-class allows you to define what exception is used as a wrapper. This means that you
can make it a RuntimeException if you need to.
Revision 1.20 2003/09/10 22:21:04 chr32
Removing > jdk 1.2 dependencies.
Revision 1.19 2003/09/05 17:01:00 billhorsman
Trap and throw FatalSQLExceptions.
Revision 1.18 2003/03/03 11:11:58 billhorsman
fixed licence
Revision 1.17 2003/02/13 17:06:42 billhorsman
allow for sqlStatement in execute() method
Revision 1.16 2003/02/06 17:41:04 billhorsman
now uses imported logging
Revision 1.15 2003/01/31 16:53:19 billhorsman
checkstyle
Revision 1.14 2003/01/28 11:47:08 billhorsman
new isTrace() and made close() public
Revision 1.13 2003/01/27 18:26:40 billhorsman
refactoring of ProxyConnection and ProxyStatement to
make it easier to write JDK 1.2 patch
Revision 1.12 2002/12/19 00:08:36 billhorsman
automatic closure of statements when a connection is closed
Revision 1.11 2002/12/16 10:57:48 billhorsman
add getDelegateStatement to allow access to the
delegate JDBC driver's Statement
Revision 1.10 2002/12/03 12:24:00 billhorsman
fixed fatal sql exception
Revision 1.9 2002/11/13 18:22:04 billhorsman
fix for trace output
Revision 1.8 2002/11/13 12:32:38 billhorsman
now correctly logs trace messages even with verbose off
Revision 1.7 2002/11/09 15:57:33 billhorsman
finished off execute logging and listening
Revision 1.6 2002/10/29 23:20:55 billhorsman
logs execute time when debug is enabled and verbose is true
Revision 1.5 2002/10/28 19:28:25 billhorsman
checkstyle
Revision 1.4 2002/10/28 08:20:23 billhorsman
draft sql dump stuff
Revision 1.3 2002/10/25 15:59:32 billhorsman
made non-public where possible
Revision 1.2 2002/10/17 15:29:18 billhorsman
fixes so that equals() works
Revision 1.1.1.1 2002/09/13 08:13:30 billhorsman
new
Revision 1.8 2002/08/24 19:57:15 billhorsman
checkstyle changes
Revision 1.7 2002/08/24 19:42:26 billhorsman
new proxy stuff to work with JDK 1.4
Revision 1.6 2002/07/10 16:14:47 billhorsman
widespread layout changes and move constants into ProxoolConstants
Revision 1.5 2002/07/02 11:19:08 billhorsman
layout code and imports
Revision 1.4 2002/06/28 11:19:47 billhorsman
improved doc
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/ShutdownHook.java 0000644 0001750 0001750 00000012660 10730503125 030006 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
/**
* This is instantiated statically by ProxoolFacade. It will automatically
* close down all the connections when the JVM stops.
* @version $Revision: 1.13 $, $Date: 2006/11/02 10:00:34 $
* @author bill
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.7
*/
class ShutdownHook implements Runnable {
private static final Log LOG = LogFactory.getLog(ShutdownHook.class);
private static boolean registered;
protected static void init() {
if (!registered) {
registered = true;
new ShutdownHook();
}
}
protected static void remove(Thread t) {
Runtime runtime = Runtime.getRuntime();
try {
final Method removeShutdownHookMethod = Runtime.class.getMethod("removeShutdownHook", new Class[] {Thread.class});
removeShutdownHookMethod.invoke(runtime, new Object[] {t});
if (LOG.isDebugEnabled()) {
LOG.debug("Removed shutdownHook");
}
} catch (NoSuchMethodException e) {
LOG.warn("Proxool will have to be shutdown manually with ProxoolFacade.shutdown() because this version of the JDK does not support Runtime.getRuntime().addShutdownHook()");
} catch (SecurityException e) {
LOG.error("Problem removing shutdownHook", e);
} catch (IllegalAccessException e) {
LOG.error("Problem removing shutdownHook", e);
} catch (InvocationTargetException e) {
// Use getTargetException() because getCause() is only supported in JDK 1.4 and later
Throwable cause = ((InvocationTargetException) e).getTargetException();
if (cause instanceof IllegalStateException) {
// This is probably because a shutdown is in progress. We can
// safely ignore that.
} else {
LOG.error("Problem removing shutdownHook", e);
}
}
}
/**
* Registers this ShutdownHook with Runtime
*/
private ShutdownHook() {
Thread t = new Thread(this);
t.setName("ShutdownHook");
Runtime runtime = Runtime.getRuntime();
try {
Method addShutdownHookMethod = Runtime.class.getMethod("addShutdownHook", new Class[] {Thread.class});
addShutdownHookMethod.invoke(runtime, new Object[] {t});
ProxoolFacade.setShutdownHook(t);
if (LOG.isDebugEnabled()) {
LOG.debug("Registered shutdownHook");
}
} catch (NoSuchMethodException e) {
LOG.warn("Proxool will have to be shutdown manually with ProxoolFacade.shutdown() because this version of the JDK does not support Runtime.getRuntime().addShutdownHook()");
} catch (SecurityException e) {
LOG.error("Problem registering shutdownHook", e);
} catch (IllegalAccessException e) {
LOG.error("Problem registering shutdownHook", e);
} catch (InvocationTargetException e) {
LOG.error("Problem registering shutdownHook", e);
}
}
/**
* Remove all connection pools without delay. Only runs if the
* shutdown hook is {@link org.logicalcobwebs.proxool.ProxoolFacade#isShutdownHookEnabled() enabled}.
* @see ProxoolFacade#removeAllConnectionPools
*/
public void run() {
if (ProxoolFacade.isShutdownHookEnabled()) {
LOG.debug("Running ShutdownHook");
Thread.currentThread().setName("Shutdown Hook");
ProxoolFacade.shutdown(0);
} else {
LOG.debug("Skipping ShutdownHook because it's been disabled");
}
}
}
/*
Revision history:
$Log: ShutdownHook.java,v $
Revision 1.13 2006/11/02 10:00:34 billhorsman
Added ProxoolFacade.disableShutdownHook.
Revision 1.12 2006/01/18 14:40:02 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.11 2003/12/16 09:09:32 billhorsman
Switched from getCause() to getTargetException() so that we can trap the IllegalStateException in all JDKs.
Revision 1.10 2003/11/16 18:19:14 chr32
Started calling to Exception.getCause() via refletion to maintain compilability with < jdk 1.4 compilers.
Revision 1.9 2003/10/27 12:32:06 billhorsman
Fixed typos and silently ignore IllegalStateException during shutdownHook removal (it's probably because
the JVM is shutting down).
Revision 1.8 2003/09/07 22:05:15 billhorsman
Now uses reflection to add ShutdownHook to Runtime so that it is JDK independent. Using JDK1.2
will disable the shutdownHook and simply log a warning message that Proxool must be shutdown
explicitly.
Revision 1.7 2003/03/03 17:07:58 billhorsman
name thread
Revision 1.6 2003/03/03 11:11:58 billhorsman
fixed licence
Revision 1.5 2003/02/26 11:20:59 billhorsman
removed debug
Revision 1.4 2003/02/10 15:13:57 billhorsman
fixed deprecated call
Revision 1.3 2003/02/06 17:41:05 billhorsman
now uses imported logging
Revision 1.2 2003/02/04 17:19:11 billhorsman
ShutdownHook now initialises
Revision 1.1 2003/02/04 15:04:17 billhorsman
New ShutdownHook
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/StateListenerIF.java 0000644 0001750 0001750 00000003143 10730503125 030353 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
/**
* Monitors the state of the pool so you can see whether it is
* quiet, busy, overloaded, or down.
*
*
* String alias = "myPool";
* StateListenerIF myStateListener = new MyStateListener();
* ProxoolFacade.{@link ProxoolFacade#addStateListener addStateListenerIF}(alias, myStateListener);
*
*
* @version $Revision: 1.5 $, $Date: 2003/03/03 11:11:58 $
* @author billhorsman
* @author $Author: billhorsman $ (current maintainer)
*/
public interface StateListenerIF {
public final int STATE_QUIET = 0;
public final int STATE_BUSY = 1;
public final int STATE_OVERLOADED = 2;
public final int STATE_DOWN = 3;
void upStateChanged(int upState);
}
/*
Revision history:
$Log: StateListenerIF.java,v $
Revision 1.5 2003/03/03 11:11:58 billhorsman
fixed licence
Revision 1.4 2003/02/08 00:35:30 billhorsman
doc
Revision 1.3 2002/12/15 19:21:42 chr32
Changed @linkplain to @link (to preserve JavaDoc for 1.2/1.3 users).
Revision 1.2 2002/10/25 16:00:27 billhorsman
added better class javadoc
Revision 1.1.1.1 2002/09/13 08:13:30 billhorsman
new
Revision 1.5 2002/07/10 16:14:47 billhorsman
widespread layout changes and move constants into ProxoolConstants
Revision 1.4 2002/06/28 11:19:47 billhorsman
improved doc
Revision 1.3 2002/06/28 11:15:41 billhorsman
didn't really need ListenerIF
*/
libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/Version.java 0000644 0001750 0001750 00000007234 11053760610 027003 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Tells you the version. You can tell what sort of release it is
* from the version. For instance:
*
* 1.0.0 (1 January)
* A proper released binary file at version 1.0.
*
* 1.0.0+
* Built from the source based on version 1.0 (but there is no
* way of knowing whether the source has been altered).
*
* 1.0.1 (2 January)
* A bug fix release built on January 2nd.
*
* @version $Revision: 1.23 $, $Date: 2008/08/23 10:08:08 $
* @author bill
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.6
*/
public class Version {
private static final Log LOG = LogFactory.getLog(Version.class);
/**
* This is changed by the Ant script when you build from the
* source code.
*/
private static final String VERSION = null;
private static final String BUILD_DATE = null;
private static final String CVS = "0.9.1+";
public static String getVersion() {
StringBuffer version = new StringBuffer();
if (VERSION != null) {
version.append(VERSION);
} else {
/**
* This means that we haven't used the Ant script so this
* is just our best guess at the version.
*/
version.append(CVS);
}
if (BUILD_DATE != null) {
version.append(" (");
version.append(BUILD_DATE);
version.append(")");
}
return version.toString();
}
/**
* Convenient way of verifying version
* @param args none required (any sent are ignored)
*/
public static void main(String[] args) {
LOG.info("Version " + getVersion());
}
}
/*
Revision history:
$Log: Version.java,v $
Revision 1.23 2008/08/23 10:08:08 billhorsman
Version 0.9.1 - packaging of Cglib
Revision 1.22 2008/08/19 19:17:11 billhorsman
Version 0.9.0
Revision 1.21 2007/01/10 09:24:35 billhorsman
0.9.0RC3
Revision 1.20 2006/01/18 14:40:02 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.19 2005/09/26 21:47:46 billhorsman
no message
Revision 1.18 2003/12/13 12:21:54 billhorsman
Release 0.8.3
Revision 1.17 2003/11/05 00:19:48 billhorsman
new revision
Revision 1.16 2003/10/27 13:13:58 billhorsman
new version
Revision 1.15 2003/10/26 15:23:30 billhorsman
0.8.0
Revision 1.14 2003/10/01 19:31:26 billhorsman
0.8.0RC2
Revision 1.13 2003/09/11 11:17:52 billhorsman
*** empty log message ***
Revision 1.12 2003/08/30 11:43:32 billhorsman
Update for next release.
Revision 1.11 2003/07/23 06:54:48 billhorsman
draft JNDI changes (shouldn't effect normal operation)
Revision 1.10 2003/06/18 10:04:47 billhorsman
versioning
Revision 1.9 2003/03/12 15:59:53 billhorsman
*** empty log message ***
Revision 1.8 2003/03/03 11:11:58 billhorsman
fixed licence
Revision 1.7 2003/02/21 15:19:09 billhorsman
update version
Revision 1.6 2003/02/12 00:50:34 billhorsman
change the CVS version to be x.y+ (a bit more informative)
Revision 1.5 2003/02/06 17:41:05 billhorsman
now uses imported logging
Revision 1.4 2003/01/21 10:56:40 billhorsman
new version approach
Revision 1.3 2003/01/16 11:45:02 billhorsman
changed format from x.y+ to x.y.*
Revision 1.2 2003/01/16 11:22:00 billhorsman
new version
Revision 1.1 2003/01/14 23:50:59 billhorsman
keeps track of version
*/ libproxool-java-0.9.1.orig/src/java/org/logicalcobwebs/proxool/WrappedConnection.java 0000644 0001750 0001750 00000032241 10730503125 030771 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool;
import org.logicalcobwebs.cglib.proxy.InvocationHandler;
import org.logicalcobwebs.cglib.proxy.MethodInterceptor;
import org.logicalcobwebs.cglib.proxy.MethodProxy;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.logicalcobwebs.proxool.proxy.InvokerFacade;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import java.sql.Statement;
import java.sql.SQLException;
import java.sql.Connection;
/**
* Wraps up a {@link ProxyConnection}. It is proxied as a {@link java.sql.Connection}
* @version $Revision: 1.6 $, $Date: 2006/01/18 14:40:02 $
* @author Bill Horsman
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.9
*/
public class WrappedConnection implements MethodInterceptor {
private static final Log LOG = LogFactory.getLog(WrappedConnection.class);
private static final String CLOSE_METHOD = "close";
private static final String IS_CLOSED_METHOD = "isClosed";
private static final String EQUALS_METHOD = "equals";
private static final String GET_META_DATA_METHOD = "getMetaData";
private static final String FINALIZE_METHOD = "finalize";
private static final String HASH_CODE_METHOD = "hashCode";
private static final String TO_STRING_METHOD = "toString";
/**
* The wrapped object. We should protect this and not expose it. We have to make sure that
* if we pass the proxyConnection to another WrappedConnection then this one can no longer
* manipulate it.
*/
private ProxyConnection proxyConnection;
private long id;
private String alias;
/**
* This gets set if the close() method is explicitly called. The {@link #getProxyConnection() proxyConnection}
* could still be {@link org.logicalcobwebs.proxool.ProxyConnectionIF#isReallyClosed() really closed} without
* this wrapper knowing about it yet.
*/
private boolean manuallyClosed;
/**
* Construct this wrapper around the proxy connection
* @param proxyConnection to wrap
*/
public WrappedConnection(ProxyConnection proxyConnection) {
this.proxyConnection = proxyConnection;
this.id = proxyConnection.getId();
this.alias= proxyConnection.getDefinition().getAlias();
}
/**
* Get the encapsulated proxy connection
* @return the proxy connection
*/
public ProxyConnection getProxyConnection() {
return proxyConnection;
}
/**
* Delegates to {@link #invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[]) invoke}
* @see MethodInterceptor#intercept(java.lang.Object, java.lang.reflect.Method, java.lang.Object[], org.logicalcobwebs.cglib.proxy.MethodProxy)
*/
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
return invoke(proxy, method, args);
}
/**
* Delegates all operations to the encapsulated {@link ProxyConnection} except for:
* A Java SQL Driver that provides a connection pool wrapper around another Driver of your choice. Very simple to migrate existing code. Fully configurable. Fast, mature and robust. Transparently adds connection pooling to your existing JDBC driver.
I want to add some better documentation right here. But in the meantime you should find comprehensive information on our web site
The latest version of this code is available from Sourceforge.
The majority of the work on Proxool (as of May 2002) was funded by Telenor Media AS
Copyright (c) 2002 - 2003 Proxool. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. All advertising materials mentioning features or use of this software must display the following acknowledgment:
"This product includes software developed by the Proxool project (The latest version is available at http://proxool.sourceforge.net/)."
4. The name "Proxool" must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact bill@logicalcobwebs.co.uk.
5. Products derived from this software may not be called "Proxool" nor may "Proxool" appear in their names without prior written permission of the Proxool Project.
6. Redistributions of any form whatsoever must retain the following acknowledgment:
"This product includes software developed by the Proxool project (The latest version is available at http://proxool.sourceforge.net/)."
THIS SOFTWARE IS PROVIDED BY THE PROXOOL PROJECT ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE PROXOOL PROJECT OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
This software consists of voluntary contributions made by many individuals on behalf of the Proxool Project. For more information on the Proxool Project please see The latest version is available at http://proxool.sourceforge.net.
libproxool-java-0.9.1.orig/src/java-examples/ 0000755 0001750 0001750 00000000000 11053761073 021055 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-examples/org/ 0000755 0001750 0001750 00000000000 11053761073 021644 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-examples/org/logicalcobwebs/ 0000755 0001750 0001750 00000000000 11053761073 024623 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-examples/org/logicalcobwebs/proxool/ 0000755 0001750 0001750 00000000000 11053761073 026325 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-examples/org/logicalcobwebs/proxool/examples/ 0000755 0001750 0001750 00000000000 11054125603 030135 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-examples/org/logicalcobwebs/proxool/examples/Simple.java 0000644 0001750 0001750 00000007717 10730503126 032245 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.examples; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; /** * The simplest example of all. Just gets a Connection. * * @version $Revision: 1.7 $, $Date: 2006/01/18 14:40:03 $ * @author billhorsman * @author $Author: billhorsman $ (current maintainer) */ public class Simple { private static final Log LOG = LogFactory.getLog(Simple.class); private static void withoutProxool() { Connection connection = null; try { Class.forName("org.hsqldb.jdbcDriver"); try { connection = DriverManager.getConnection("jdbc:hsqldb:test"); } catch (SQLException e) { LOG.error("Problem getting connection", e); } if (connection != null) { LOG.info("Got connection :)"); } else { LOG.error("Didn't get connection, which probably means that no Driver accepted the URL"); } } catch (ClassNotFoundException e) { LOG.error("Couldn't find driver", e); } finally { try { // Check to see we actually got a connection before we // attempt to close it. if (connection != null) { connection.close(); } } catch (SQLException e) { LOG.error("Problem closing connection", e); } } } private static void withProxool() { Connection connection = null; try { // NOTE THIS LINE Class.forName("org.logicalcobwebs.proxool.ProxoolDriver"); try { // NOTE THIS LINE connection = DriverManager.getConnection("proxool.example:org.hsqldb.jdbcDriver:jdbc:hsqldb:test"); } catch (SQLException e) { LOG.error("Problem getting connection", e); } if (connection != null) { LOG.info("Got connection :)"); } else { LOG.error("Didn't get connection, which probably means that no Driver accepted the URL"); } } catch (ClassNotFoundException e) { LOG.error("Couldn't find driver", e); } finally { try { // Check to see we actually got a connection before we // attempt to close it. if (connection != null) { connection.close(); } } catch (SQLException e) { LOG.error("Problem closing connection", e); } } } /** * Tests getting a connection with and without Proxool */ public static void main(String[] args) { withoutProxool(); withProxool(); } } /* Revision history: $Log: Simple.java,v $ Revision 1.7 2006/01/18 14:40:03 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.6 2003/03/03 11:12:02 billhorsman fixed licence Revision 1.5 2003/02/06 17:41:03 billhorsman now uses imported logging Revision 1.4 2003/02/06 15:42:48 billhorsman updated (overdue!) Revision 1.3 2002/12/03 10:54:04 billhorsman use hypersonic driver Revision 1.2 2002/09/19 10:01:37 billhorsman improved error handling and logging Revision 1.1 2002/09/19 08:51:09 billhorsman created new examples package Revision 1.1.1.1 2002/09/13 08:14:27 billhorsman new Revision 1.4 2002/07/10 16:14:47 billhorsman widespread layout changes and move constants into ProxoolConstants Revision 1.3 2002/07/02 11:19:08 billhorsman layout code and imports Revision 1.2 2002/06/28 11:19:47 billhorsman improved doc */ libproxool-java-0.9.1.orig/src/java-sandbox/ 0000755 0001750 0001750 00000000000 11053761073 020675 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-sandbox/org/ 0000755 0001750 0001750 00000000000 11053761073 021464 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-sandbox/org/logicalcobwebs/ 0000755 0001750 0001750 00000000000 11053761073 024443 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-sandbox/org/logicalcobwebs/proxool/ 0000755 0001750 0001750 00000000000 11054125603 026137 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-sandbox/org/logicalcobwebs/proxool/VirtoolDriver.java 0000644 0001750 0001750 00000005553 10730503132 031621 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool; import java.sql.Connection; import java.sql.Driver; import java.sql.DriverManager; import java.sql.DriverPropertyInfo; import java.sql.SQLException; import java.util.Properties; /** * This class acts as a virtual pool. When you ask it for a connection it * delegates to one of the designated real pools. Some assumptions: * * Getting a connection needs to be very fast. * * Switching pools can be relatively slow (but just to get that in perspective, * > 100ms) * * We should detect pools that don't respond (timeout), throw certain * SQLExceptions, or are unacceptably slow. * * We should also allow simple load balancing between pools that are * up. * * @version $Revision: 1.2 $, $Date: 2003/03/03 11:12:02 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ public class VirtoolDriver implements Driver { private static final String VIRTOOL = "virtool"; private String[] activePools; private int nextPool; public Connection connect(String url, Properties info) throws SQLException { String alias = activePools[nextPool]; // Now we need to move to the next pool. This code isn't ThreadSafe and // we don't want to make it so because it would have a performance // impact. return null; } public boolean acceptsURL(String url) throws SQLException { return (url.startsWith(VIRTOOL)); } public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException { return new DriverPropertyInfo[0]; } public int getMajorVersion() { throw new UnsupportedOperationException("This virtual driver doesn't support this operation."); } public int getMinorVersion() { throw new UnsupportedOperationException("This virtual driver doesn't support this operation."); } public boolean jdbcCompliant() { throw new UnsupportedOperationException("This virtual driver doesn't support this operation."); } static { try { DriverManager.registerDriver(new VirtoolDriver()); } catch (SQLException e) { System.out.println(e.toString()); } } } /* Revision history: $Log: VirtoolDriver.java,v $ Revision 1.2 2003/03/03 11:12:02 billhorsman fixed licence Revision 1.1 2002/12/15 19:00:32 chr32 Moved over from 'ext' source tree. Revision 1.3 2002/11/12 20:19:18 billhorsman added some doc Revision 1.2 2002/10/27 13:05:01 billhorsman checkstyle Revision 1.1 2002/10/27 12:05:39 billhorsman early, early draft */ libproxool-java-0.9.1.orig/src/java-test/ 0000755 0001750 0001750 00000000000 11053761073 020216 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-test/org/ 0000755 0001750 0001750 00000000000 11053761073 021005 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/ 0000755 0001750 0001750 00000000000 11053761073 023764 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/cglib/ 0000755 0001750 0001750 00000000000 11054125603 025036 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/cglib/EnhancerTest.java 0000644 0001750 0001750 00000003107 10730503131 030261 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.cglib; import org.logicalcobwebs.proxool.AbstractProxoolTest; import org.logicalcobwebs.cglib.proxy.Enhancer; /** * A test test class (!) to help me understand the Enhancer. It fails. Or at least, * it would do if I uncommented the assert. But that fines. It's a learning process. * @version $Revision: 1.2 $, $Date: 2004/06/02 20:55:54 $ * @author billhorsman * @author $Author: billhorsman $ (current maintainer) */ public class EnhancerTest extends AbstractProxoolTest { public EnhancerTest(String alias) { super(alias); } public void testConcreteClassEnhancer() { MyInterfaceIF mi = (MyInterfaceIF) Enhancer.create( null, new Class[] {MyInterfaceIF.class}, new MyProxy(new MyConcreteClass())); mi.bar(); try { MyConcreteClass mcc = (MyConcreteClass) mi; } catch (ClassCastException e) { // Expected this :( } // This fails // assertEquals("foo()", "proxiedFoo", mcc.foo()); } } /* Revision history: $Log: EnhancerTest.java,v $ Revision 1.2 2004/06/02 20:55:54 billhorsman Make sure test doesn't throw a ClassCastException Revision 1.1 2004/06/02 20:54:57 billhorsman Learning test class for Enhancer. It fails (or would if the assert was uncommented). Left in for knowledge. */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/cglib/MyConcreteClass.java 0000644 0001750 0001750 00000002255 10730503131 030737 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.cglib; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * See {@link EnhancerTest} * @version $Revision: 1.3 $, $Date: 2006/01/18 14:40:03 $ * @author billhorsman * @author $Author: billhorsman $ (current maintainer) */ public class MyConcreteClass implements MyInterfaceIF { private static final Log LOG = LogFactory.getLog(MyConcreteClass.class); MyConcreteClass() { LOG.debug("MyConcreteClass.init"); } public String foo() { return "foo"; } public void bar() {} } /* Revision history: $Log: MyConcreteClass.java,v $ Revision 1.3 2006/01/18 14:40:03 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.2 2004/06/17 21:40:06 billhorsman Log message should be debug not error Revision 1.1 2004/06/02 20:54:57 billhorsman Learning test class for Enhancer. It fails (or would if the assert was uncommented). Left in for knowledge. */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/cglib/MyInterfaceIF.java 0000644 0001750 0001750 00000001301 10730503131 030315 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.cglib; /** * See {@link EnhancerTest} * @version $Revision: 1.1 $, $Date: 2004/06/02 20:54:57 $ * @author billhorsman * @author $Author: billhorsman $ (current maintainer) */ public interface MyInterfaceIF { public void bar(); } /* Revision history: $Log: MyInterfaceIF.java,v $ Revision 1.1 2004/06/02 20:54:57 billhorsman Learning test class for Enhancer. It fails (or would if the assert was uncommented). Left in for knowledge. */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/cglib/MyProxy.java 0000644 0001750 0001750 00000002363 10730503131 027330 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.cglib; import org.logicalcobwebs.cglib.proxy.MethodInterceptor; import org.logicalcobwebs.cglib.proxy.MethodProxy; import java.lang.reflect.Method; /** * See {@link EnhancerTest} * @version $Revision: 1.1 $, $Date: 2004/06/02 20:54:57 $ * @author billhorsman * @author $Author: billhorsman $ (current maintainer) */ public class MyProxy implements MethodInterceptor { private MyConcreteClass myConcreteClass; public MyProxy(MyConcreteClass myConcreteClass) { this.myConcreteClass = myConcreteClass; } public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { if (method.getName().equals("foo")) { return "proxiedFoo"; } else { return method.invoke(myConcreteClass, args); } } } /* Revision history: $Log: MyProxy.java,v $ Revision 1.1 2004/06/02 20:54:57 billhorsman Learning test class for Enhancer. It fails (or would if the assert was uncommented). Left in for knowledge. */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/dbscript/ 0000755 0001750 0001750 00000000000 11054125603 025570 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/dbscript/Command.java 0000644 0001750 0001750 00000010034 10730503127 030010 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.dbscript; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * An SQL command that isrun by a {@link Script}. If {@link #getLoad load} * or {@link #getLoops loops} are configured then it might run more than * once. * * @version $Revision: 1.9 $, $Date: 2006/01/18 14:40:04 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ class Command implements CommandIF { private static final Log LOG = LogFactory.getLog(Command.class); private String name; private String sql; private int load = 1; private int loops = 1; private String exception; /** * If this command encounters an exception it will stop executing (and if * it is in a loop it will break out of the loop) */ protected static final String EXCEPTION_STOP = "stop"; /** * If this command encounters an exception it will log it at DEBUG * level and continue */ protected static final String EXCEPTION_LOG = "log"; /** * If this command encounters an exception it will silently ignore the * exception and continue. But it still calls the */ protected static final String EXCEPTION_IGNORE = "ignore"; /** * @see CommandIF#getSql */ public String getSql() { return sql; } /** * @see #getSql */ protected void setSql(String sql) { this.sql = sql; } /** * @see CommandIF#getLoad */ public int getLoad() { return load; } /** * @see #getLoad */ protected void setLoad(int load) { this.load = load; } /** * @see CommandIF#getLoops */ public int getLoops() { return loops; } /** * @see #getLoops */ protected void setLoops(int loops) { this.loops = loops; } /** * @see CommandIF#isIgnoreException */ public boolean isIgnoreException() { return exception != null && exception.equals(EXCEPTION_IGNORE); } /** * @see CommandIF#isIgnoreException */ public boolean isLogException() { return exception != null && exception.equals(EXCEPTION_LOG); } /** * @see #isIgnoreException */ public void setException(String exception) { if (exception == null) { this.exception = EXCEPTION_STOP; LOG.debug("Setting exception to default " + EXCEPTION_STOP); } else if (exception.equals(EXCEPTION_IGNORE) || exception.equals(EXCEPTION_LOG) || exception.equals(EXCEPTION_STOP)) { this.exception = exception; LOG.debug("Setting exception to " + exception); } else { throw new RuntimeException("Unknown exception value: " + exception); } } /** * @see CommandIF#getName */ public String getName() { return name; } /** * @see #getName */ public void setName(String name) { this.name = name; } } /* Revision history: $Log: Command.java,v $ Revision 1.9 2006/01/18 14:40:04 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.8 2003/03/03 11:12:02 billhorsman fixed licence Revision 1.7 2003/02/19 15:14:18 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.6 2003/02/06 17:41:01 billhorsman now uses imported logging Revision 1.5 2002/11/09 15:58:12 billhorsman fix doc Revision 1.4 2002/11/09 14:45:07 billhorsman now threaded and better exception handling Revision 1.3 2002/11/06 21:07:03 billhorsman Now supports the CommandIF interface Revision 1.2 2002/11/02 14:22:16 billhorsman Documentation Revision 1.1 2002/11/02 11:29:53 billhorsman new script runner for testing */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/dbscript/CommandFilterIF.java 0000644 0001750 0001750 00000004567 10730503127 031413 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.dbscript; import java.sql.Connection; import java.sql.SQLException; /** * Allows you to perform tasks just {@link #beforeCommand before} and just * {@link #afterCommand after} a {@link CommandIF command} is executed. * You can also {@link #catchException catch} exceptions that happen. * * @version $Revision: 1.5 $, $Date: 2003/03/03 11:12:03 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ public interface CommandFilterIF { /** * Implement this if you want to do something special before each command is run. * @param connection the connection being used * @param command the command about to be run * @return true if the command should be executed, or false to skip the command * @throws SQLException if anything goes wrong. This will terminate the script. */ boolean beforeCommand(Connection connection, CommandIF command) throws SQLException; /** * Implement this if you want to do something special after each command is run * but before the connection is closed * @param connection the connection being used * @param command the command that was run * @throws SQLException if anything goes wrong. This will terminate the script. */ void afterCommand(Connection connection, CommandIF command) throws SQLException; /** * Any SQLException will be passed to this method. * @param e the exception * @return true if execution should continue, false if it should stop (including any remaining executions in the loop) */ boolean catchException(CommandIF command, SQLException e); } /* Revision history: $Log: CommandFilterIF.java,v $ Revision 1.5 2003/03/03 11:12:03 billhorsman fixed licence Revision 1.4 2003/02/19 15:14:19 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.3 2002/11/09 15:58:37 billhorsman fix and added doc Revision 1.2 2002/11/09 14:45:07 billhorsman now threaded and better exception handling Revision 1.1 2002/11/06 21:07:42 billhorsman New interfaces to allow filtering of commands */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/dbscript/CommandIF.java 0000644 0001750 0001750 00000004124 10730503127 030232 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.dbscript; /** * An SQL command to run. * * @version $Revision: 1.5 $, $Date: 2003/03/03 11:12:03 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ public interface CommandIF { /** * The SQL statement to run * @return sql */ String getSql(); /** * How many "threads" to simulate. See {@link org.logicalcobwebs.dbscript.Script} to see how * it actually implements thread-like behaviour. * @return load */ int getLoad(); /** * The number of loops to perform. Each loop will run the {@link #getSql sql} * {@link #getLoad load} times. * @return loops */ int getLoops(); /** * If true then errors that occur during this command are ignored silently * and do not stop the {@link org.logicalcobwebs.dbscript.Script script} running. * @return true if exceptions should be ignored */ boolean isIgnoreException(); /** * If true then errors that occur during this command are logged as debug * messages but do not stop the {@link org.logicalcobwebs.dbscript.Script script} running. * @return true if exceptions should be logged */ boolean isLogException(); /** * A convenient name to call this command to help logging. * @return name */ String getName(); } /* Revision history: $Log: CommandIF.java,v $ Revision 1.5 2003/03/03 11:12:03 billhorsman fixed licence Revision 1.4 2003/02/19 15:14:19 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.3 2002/11/09 15:58:54 billhorsman fix and added doc Revision 1.2 2002/11/09 14:45:07 billhorsman now threaded and better exception handling Revision 1.1 2002/11/06 21:07:42 billhorsman New interfaces to allow filtering of commands */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/dbscript/Commander.java 0000644 0001750 0001750 00000011237 10730503127 030345 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.dbscript; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.sql.Connection; import java.sql.SQLException; import java.sql.Statement; /** * A thread that can run a single command many times. * * @version $Revision: 1.7 $, $Date: 2006/01/18 14:40:05 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ class Commander implements Runnable { private static final Log LOG = LogFactory.getLog(Commander.class); private ConnectionAdapterIF adapter; private CommandIF command; private CommandFilterIF commandFilter; private boolean finished = false; public Commander(ConnectionAdapterIF adapter, CommandIF commandIF, CommandFilterIF commandFilter) { this.adapter = adapter; this.command = commandIF; this.commandFilter = commandFilter; } public void run() { try { boolean keepGoing = true; for (int i = 0; i < command.getLoops(); i++) { Connection connection = null; try { connection = adapter.getConnection(); boolean executeCommand = true; if (commandFilter != null) { executeCommand = commandFilter.beforeCommand(connection, command); } if (executeCommand) { execute(connection, command.getSql()); } if (commandFilter != null) { commandFilter.afterCommand(connection, command); } } catch (SQLException e) { if (commandFilter != null && !commandFilter.catchException(command, e)) { keepGoing = false; } if (command.isIgnoreException()) { // Silent } else if (command.isLogException()) { LOG.debug("Ignoring exception in " + command.getName(), e); } else { LOG.error("Stopping command " + command.getName(), e); keepGoing = false; } } finally { try { adapter.closeConnection(connection); } catch (SQLException e) { LOG.error("Closing connection for " + Thread.currentThread().getName(), e); } } if (!keepGoing) { break; } // Give other threads a chance. (Hoping this will increase the chances // of some sort of conflict) Thread.yield(); } } finally { finished = true; } } /** * Is the thread running * @return true if it's finished, else false */ protected boolean isFinished() { return finished; } /** * Execute and SQL statement * @param connection used to execute statement * @param sql the SQL to perform * @throws java.sql.SQLException if anything goes wrong */ private static final void execute(Connection connection, String sql) throws SQLException { Statement statement = null; try { statement = connection.createStatement(); statement.execute(sql); } finally { if (statement != null) { try { if (statement != null) { statement.close(); } } catch (SQLException e) { LOG.error("Couldn't close statement", e); } } } } } /* Revision history: $Log: Commander.java,v $ Revision 1.7 2006/01/18 14:40:05 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.6 2003/03/03 11:12:03 billhorsman fixed licence Revision 1.5 2003/02/19 15:14:20 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.4 2003/02/06 17:41:02 billhorsman now uses imported logging Revision 1.3 2003/01/15 00:08:15 billhorsman check for commandFilter existence to avoid unnecessary log clutter Revision 1.2 2002/11/09 15:59:18 billhorsman fix doc Revision 1.1 2002/11/09 14:45:07 billhorsman now threaded and better exception handling */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/dbscript/ConnectionAdapterIF.java 0000644 0001750 0001750 00000005472 10730503127 032263 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.dbscript; import org.logicalcobwebs.proxool.ProxoolException; import java.util.Properties; import java.sql.SQLException; import java.sql.Connection; /** * An interface that will provide connections. It differs from a real * {@link java.sql.Driver Driver} because it has {@link #setup} and * {@link #tearDown} methods. * * @version $Revision: 1.8 $, $Date: 2003/03/03 11:12:03 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ public interface ConnectionAdapterIF { /** * Setup the adapter. Define the connection. Prototype any connections * as necessary. * * @param driver the name of the class * @param url the url to pass to the driver * @param info the properties to pass to the driver * @throws SQLException if anything goes wrong */ void setup(String driver, String url, Properties info) throws SQLException, ProxoolException; /** * Simply get a connection (using the definitions defined in {@link #setup} * @return the connection * @throws SQLException if anything goes wrong */ Connection getConnection() throws SQLException; /** * This gives the adapter the flexibilty of closing the connection for real * or just putting it back in a pool. * @param connection the connection to "close" * @throws SQLException if anything goes wrong */ void closeConnection(Connection connection) throws SQLException; /** * Reclaim resources used by the adapter (for instance, close any * open connections) */ void tearDown() throws ProxoolException; /** * Convenient name so we can identify this adapter in logs. * @return name */ String getName(); } /* Revision history: $Log: ConnectionAdapterIF.java,v $ Revision 1.8 2003/03/03 11:12:03 billhorsman fixed licence Revision 1.7 2003/02/19 15:14:21 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.6 2003/01/17 00:38:12 billhorsman wide ranging changes to clarify use of alias and url - this has led to some signature changes (new exceptions thrown) on the ProxoolFacade API. Revision 1.5 2002/11/13 20:23:34 billhorsman change method name, throw exceptions differently, trivial changes Revision 1.4 2002/11/09 15:59:34 billhorsman fix doc Revision 1.3 2002/11/02 14:22:16 billhorsman Documentation Revision 1.2 2002/11/02 12:46:42 billhorsman improved debug Revision 1.1 2002/11/02 11:29:53 billhorsman new script runner for testing */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/dbscript/Script.java 0000644 0001750 0001750 00000005454 10730503127 027710 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.dbscript; import java.util.List; import java.util.Properties; import java.util.Vector; /** * Defines a set of {@link #getCommands commands} to run. And which * {@link #getDriver driver} to use. And its {@link #getInfo configuration}. * * @version $Revision: 1.6 $, $Date: 2003/03/03 11:12:03 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ class Script { private String name; private String driver; private String url; private Properties info = new Properties(); private List commands = new Vector(); /** * Add a command to the script. * @param command to add */ protected void addCommand(Command command) { commands.add(command); } /** * Get all the commands, in the order in which they were added * @return list of commands */ protected Command[] getCommands() { return (Command[]) commands.toArray(new Command[commands.size()]); } /** * So we can recognise this script in the logs * @return name */ protected String getName() { return name; } /** * @see #getName */ protected void setName(String name) { this.name = name; } /** * The URL to pass to the Driver */ protected String getUrl() { return url; } /** * @see #getUrl */ protected void setUrl(String url) { this.url = url; } /** * The driver to use * @return the driver */ protected String getDriver() { return driver; } /** * @see #getDriver */ protected void setDriver(String driver) { this.driver = driver; } /** * Configuration of the Driver * @return properties */ protected Properties getInfo() { return info; } /** * Add a new property * @param name name of property * @param value value of property */ protected void addProperty(String name, String value) { info.setProperty(name, value); } } /* Revision history: $Log: Script.java,v $ Revision 1.6 2003/03/03 11:12:03 billhorsman fixed licence Revision 1.5 2003/02/19 15:14:21 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.4 2002/11/09 15:59:52 billhorsman fix doc Revision 1.3 2002/11/02 14:22:16 billhorsman Documentation Revision 1.2 2002/11/02 13:57:34 billhorsman checkstyle Revision 1.1 2002/11/02 11:29:53 billhorsman new script runner for testing */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/dbscript/ScriptBuilder.java 0000644 0001750 0001750 00000006410 10730503127 031210 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.dbscript; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.xml.sax.Attributes; import org.xml.sax.SAXException; import org.xml.sax.helpers.DefaultHandler; /** * Parser to get {@link org.logicalcobwebs.dbscript.Script} from XML source * * @version $Revision: 1.9 $, $Date: 2006/01/18 14:40:05 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ class ScriptBuilder extends DefaultHandler { private static final Log LOG = LogFactory.getLog(ScriptBuilder.class); private Script script = null; /** * @see DefaultHandler#startElement */ public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { if (qName.equals("script")) { script = new Script(); script.setName(attributes.getValue("name")); script.setDriver(attributes.getValue("driver")); script.setUrl(attributes.getValue("url")); } else if (qName.equals("info")) { String name = attributes.getValue("name"); String value = attributes.getValue("value"); script.addProperty(name, value); } else if (qName.equals("command")) { Command command = new Command(); command.setName(attributes.getValue("name")); command.setSql(attributes.getValue("sql")); if (attributes.getValue("load") != null) { int load = Integer.parseInt(attributes.getValue("load")); command.setLoad(load); } if (attributes.getValue("loops") != null) { int loops = Integer.parseInt(attributes.getValue("loops")); command.setLoops(loops); } if (attributes.getValue("exception") != null) { String exception = attributes.getValue("exception"); command.setException(exception); } script.addCommand(command); } } /** * Get the script we just built. Call *after* {@link javax.xml.parsers.SAXParser#parse parsing} * @return the new script */ protected Script getScript() { return script; } } /* Revision history: $Log: ScriptBuilder.java,v $ Revision 1.9 2006/01/18 14:40:05 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.8 2003/03/03 11:12:03 billhorsman fixed licence Revision 1.7 2003/02/19 15:14:21 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.6 2003/02/06 17:41:02 billhorsman now uses imported logging Revision 1.5 2002/11/09 16:00:08 billhorsman fix doc Revision 1.4 2002/11/09 14:45:07 billhorsman now threaded and better exception handling Revision 1.3 2002/11/02 14:22:16 billhorsman Documentation Revision 1.2 2002/11/02 13:57:34 billhorsman checkstyle Revision 1.1 2002/11/02 11:29:53 billhorsman new script runner for testing */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/dbscript/ScriptFacade.java 0000644 0001750 0001750 00000012405 10730503127 030766 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.dbscript; import org.xml.sax.ErrorHandler; import org.xml.sax.SAXParseException; import org.xml.sax.SAXException; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.logicalcobwebs.proxool.ProxoolException; import javax.xml.parsers.SAXParserFactory; import javax.xml.parsers.SAXParser; import javax.xml.parsers.FactoryConfigurationError; import javax.xml.parsers.ParserConfigurationException; import java.io.File; import java.io.IOException; import java.sql.SQLException; /** * Allows you to run scripts from file. * * @version $Revision: 1.12 $, $Date: 2006/01/18 14:40:05 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ public class ScriptFacade { private static final Log LOG = LogFactory.getLog(ScriptFacade.class); /** * Run the script using the appropriate handler * @param scriptLocation the path to the file that contains the script XML * @param adapter so we know where to get {@link java.sql.Connection connections} from. */ public static void runScript(String scriptLocation, ConnectionAdapterIF adapter) { runScript(scriptLocation, adapter, null); } /** * Run the script using the appropriate handler * @param scriptLocation the path to the file that contains the script XML * @param adapter so we know where to get {@link java.sql.Connection connections} from. * @param commandFilter allows you to filter which commands get run and do things to the {@link java.sql.Connection} */ public static void runScript(String scriptLocation, ConnectionAdapterIF adapter, CommandFilterIF commandFilter) { File scriptFile = new File(scriptLocation); if (!scriptFile.canRead()) { throw new RuntimeException("Can't read from file at " + scriptFile.getAbsolutePath()); } try { SAXParserFactory saxParserFactory = SAXParserFactory.newInstance(); saxParserFactory.setValidating(false); saxParserFactory.setNamespaceAware(true); SAXParser saxParser = saxParserFactory.newSAXParser(); saxParser.getXMLReader().setFeature("http://xml.org/sax/features/namespaces", true); saxParser.getXMLReader().setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LOG.warn(exception.getLineNumber() + ":" + exception.getColumnNumber(), exception); } public void error(SAXParseException exception) throws SAXException { LOG.error(exception.getLineNumber() + ":" + exception.getColumnNumber(), exception); } public void fatalError(SAXParseException exception) throws SAXException { LOG.error(exception.getLineNumber() + ":" + exception.getColumnNumber(), exception); } }); ScriptBuilder scriptBuilder = new ScriptBuilder(); saxParser.parse(scriptFile, scriptBuilder); Script script = scriptBuilder.getScript(); ScriptRunner.runScript(script, adapter, commandFilter); } catch (FactoryConfigurationError factoryConfigurationError) { LOG.error(factoryConfigurationError); } catch (ParserConfigurationException e) { LOG.error("Problem running script " + scriptLocation, e); } catch (SAXException e) { LOG.error("Problem running script " + scriptLocation, e); } catch (IOException e) { LOG.error("Problem running script " + scriptLocation, e); } catch (SQLException e) { LOG.error("Problem running script " + scriptLocation, e); } catch (ProxoolException e) { LOG.error("Problem running script " + scriptLocation, e); } } } /* Revision history: $Log: ScriptFacade.java,v $ Revision 1.12 2006/01/18 14:40:05 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.11 2003/03/03 11:12:03 billhorsman fixed licence Revision 1.10 2003/02/19 15:14:21 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.9 2003/02/06 17:41:02 billhorsman now uses imported logging Revision 1.8 2003/01/17 00:38:12 billhorsman wide ranging changes to clarify use of alias and url - this has led to some signature changes (new exceptions thrown) on the ProxoolFacade API. Revision 1.7 2002/11/13 20:23:35 billhorsman change method name, throw exceptions differently, trivial changes Revision 1.6 2002/11/09 16:00:21 billhorsman fix doc Revision 1.5 2002/11/07 19:08:54 billhorsman Fixed up tests a bit Revision 1.4 2002/11/06 21:06:21 billhorsman Support for CommandFilterIF Revision 1.3 2002/11/02 14:22:16 billhorsman Documentation Revision 1.2 2002/11/02 13:57:34 billhorsman checkstyle Revision 1.1 2002/11/02 11:29:53 billhorsman new script runner for testing */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/dbscript/ScriptRunner.java 0000644 0001750 0001750 00000010351 10730503127 031072 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.dbscript; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.logicalcobwebs.proxool.ProxoolException; import java.sql.SQLException; /** * Run a {@link Script script}. * * @version $Revision: 1.12 $, $Date: 2006/01/18 14:40:05 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ public class ScriptRunner { private static final Log LOG = LogFactory.getLog(ScriptRunner.class); /** * Run the script. * * @param script to run * @param adapter so we know where to connections from * @throws SQLException if anything goes wrong */ protected static final void runScript(Script script, ConnectionAdapterIF adapter, CommandFilterIF commandFilter) throws SQLException, ProxoolException { adapter.setup(script.getDriver(), script.getUrl(), script.getInfo()); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); //To change body of catch statement use Options | File Templates. } Command[] commands = script.getCommands(); for (int i = 0; i < commands.length; i++) { Command command = commands[i]; long start = System.currentTimeMillis(); // Execute the SQL Commander[] commanders = new Commander[command.getLoad()]; for (int load = 0; load < command.getLoad(); load++) { commanders[load] = new Commander(adapter, command, commandFilter); Thread t = new Thread(commanders[load]); t.setName(script.getName() + "." + command.getName() + "." + load); t.start(); } while (true) { try { Thread.sleep(1000); } catch (InterruptedException e) { LOG.error("Awoken from sleep", e); } int remaining = command.getLoad(); for (int load = 0; load < command.getLoad(); load++) { if (commanders[load].isFinished()) { remaining--; } } if (remaining > 0) { // LOG.debug("Waiting for " + remaining + " threads to complete."); } else { break; } } long elapsed = System.currentTimeMillis() - start; int count = command.getLoad() * command.getLoops(); double lap = (double) elapsed / (double) count; if (count > 1) { LOG.info(adapter.getName() + ":" + command.getName() + " ran " + count + " commands in " + elapsed + " milliseconds (avg." + lap + ")"); } else { LOG.debug(adapter.getName() + ":" + command.getName() + " ran in " + elapsed + " milliseconds"); } } } } /* Revision history: $Log: ScriptRunner.java,v $ Revision 1.12 2006/01/18 14:40:05 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.11 2003/03/03 11:12:03 billhorsman fixed licence Revision 1.10 2003/02/19 15:14:21 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.9 2003/02/06 17:41:02 billhorsman now uses imported logging Revision 1.8 2003/01/17 00:38:12 billhorsman wide ranging changes to clarify use of alias and url - this has led to some signature changes (new exceptions thrown) on the ProxoolFacade API. Revision 1.7 2002/11/09 16:00:34 billhorsman fix doc Revision 1.6 2002/11/09 14:45:07 billhorsman now threaded and better exception handling Revision 1.5 2002/11/06 21:07:14 billhorsman Support for CommandFilterIF Revision 1.4 2002/11/02 14:22:16 billhorsman Documentation Revision 1.3 2002/11/02 13:57:34 billhorsman checkstyle Revision 1.2 2002/11/02 12:45:54 billhorsman improved debug Revision 1.1 2002/11/02 11:29:53 billhorsman new script runner for testing */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/ 0000755 0001750 0001750 00000000000 11054125603 025460 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/ 0000755 0001750 0001750 00000000000 11054125603 026550 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/jmx/ 0000755 0001750 0001750 00000000000 11054125603 027346 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/jmx/AbstractJMXTest.java 0000644 0001750 0001750 00000003767 10730503130 033203 0 ustar twerner twerner package org.logicalcobwebs.proxool.admin.jmx; import java.util.Properties; import java.sql.SQLException; import java.sql.DriverManager; import org.logicalcobwebs.proxool.AbstractProxoolTest; import org.logicalcobwebs.proxool.TestHelper; import org.logicalcobwebs.proxool.TestConstants; import org.logicalcobwebs.proxool.ProxoolConstants; /** * Parent class for the JMX tests. * * @version $Revision: 1.1 $, $Date: 2003/10/20 07:40:44 $ * @author Christian Nedregaard (christian_nedregaard@email.com) * @author $Author: chr32 $ (current maintainer) * @since Proxool 0.8 */ public class AbstractJMXTest extends AbstractProxoolTest { /** * @see junit.framework.TestCase#TestCase(java.lang.String) */ public AbstractJMXTest(String alias) { super(alias); } /** * Create a very basic Proxool pool. * @param alias the alias of the pool * @return the properties used to create the pool. * @throws SQLException if the pool creation fails. */ protected Properties createBasicPool(String alias) throws SQLException { final String url = TestHelper.buildProxoolUrl(alias, TestConstants.HYPERSONIC_DRIVER, TestConstants.HYPERSONIC_TEST_URL); final Properties info = createBasicProperties(alias); DriverManager.getConnection(url, info).close(); return info; } /** * Create some very basic Proxool configuration. * @param alias the alias of the pool to be configured. * @return the created properties. */ protected Properties createBasicProperties(String alias) { final Properties info = new Properties(); info.setProperty(ProxoolConstants.USER_PROPERTY, TestConstants.HYPERSONIC_USER); info.setProperty(ProxoolConstants.PASSWORD_PROPERTY, TestConstants.HYPERSONIC_PASSWORD); info.setProperty(ProxoolConstants.JMX_PROPERTY, Boolean.TRUE.toString()); info.setProperty(ProxoolConstants.FATAL_SQL_EXCEPTION_PROPERTY, alias); return info; } } libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/jmx/AllTests.java 0000644 0001750 0001750 00000003210 10730503131 031734 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.admin.jmx; import junit.extensions.TestSetup; import junit.framework.Test; import junit.framework.TestSuite; import org.logicalcobwebs.proxool.GlobalTest; /** * Run all tests in the jmx package. * * @version $Revision: 1.5 $, $Date: 2003/10/20 07:40:44 $ * @author Christian Nedregaard (christian_nedregaard@email.com) * @author $Author: chr32 $ (current maintainer) * @since Proxool 0.8 */ public class AllTests { /** * Create a composite test of all the tests in the jmx package. * @return test suite */ public static Test suite() { TestSuite suite = new TestSuite(); suite.addTestSuite(ConnectionPoolMBeanTest.class); suite.addTestSuite(MultipleAgentsConnectionPoolMBeanTest.class); // create a wrapper for global initialization code. TestSetup wrapper = new TestSetup(suite) { public void setUp() throws Exception { GlobalTest.globalSetup(); } }; return wrapper; } } /* Revision history: $Log: AllTests.java,v $ Revision 1.5 2003/10/20 07:40:44 chr32 Improved tests. Revision 1.4 2003/05/06 23:17:12 chr32 Moving JMX tests back in from sandbox. Revision 1.1 2003/03/07 16:35:17 billhorsman moved jmx stuff into sandbox until it is tested Revision 1.2 2003/03/03 11:12:06 billhorsman fixed licence Revision 1.1 2003/02/26 19:03:43 chr32 Init rev. */ ././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/jmx/ConnectionPoolMBeanTest.java libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/jmx/ConnectionPoolMBeanTes0000644 0001750 0001750 00000027756 10730503130 033615 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.admin.jmx; import org.logicalcobwebs.proxool.ProxoolConstants; import org.logicalcobwebs.proxool.ProxoolDriver; import org.logicalcobwebs.proxool.ProxoolException; import org.logicalcobwebs.proxool.ProxoolFacade; import javax.management.Attribute; import javax.management.AttributeList; import javax.management.MBeanServer; import javax.management.MBeanServerFactory; import javax.management.Notification; import javax.management.NotificationFilter; import javax.management.NotificationFilterSupport; import javax.management.NotificationListener; import javax.management.ObjectName; import java.util.Iterator; import java.util.Properties; /** * Test {@link org.logicalcobwebs.proxool.admin.jmx.ConnectionPoolMBean}. * * @version $Revision: 1.10 $, $Date: 2003/10/20 07:40:44 $ * @author Christian Nedregaard (christian_nedregaard@email.com) * @author $Author: chr32 $ (current maintainer) * @since Proxool 0.8 */ public class ConnectionPoolMBeanTest extends AbstractJMXTest { private MBeanServer mBeanServer; private boolean notified; /** * @see junit.framework.TestCase#TestCase(java.lang.String) */ public ConnectionPoolMBeanTest(String s) { super(s); } /** * Test that an attribute can be fetched from the MBean. * @throws java.lang.Exception if an error occours. */ public void testGetAttribute() throws Exception { final String alias = "testGetAttribute"; createBasicPool(alias); final ObjectName objectName = ProxoolJMXHelper.getObjectName(alias); final String fatalSql = (String) this.mBeanServer.getAttribute(objectName, ProxoolJMXHelper.getValidIdentifier(ProxoolConstants.FATAL_SQL_EXCEPTION)); assertTrue("Expected fatalSQLException to be '" + alias + "', but it was '" + fatalSql + "'. ", fatalSql.equals(alias)); ProxoolFacade.removeConnectionPool(alias); } /** * Test that a list attributes can be fetched from the MBean. * @throws java.lang.Exception if an error occours. */ public void testGetAttributes() throws Exception { final String alias = "testGetAttributes"; createBasicPool(alias); final String fatalSQLAttribute = ProxoolJMXHelper.getValidIdentifier(ProxoolConstants.FATAL_SQL_EXCEPTION); final String aliasAttribute = ProxoolJMXHelper.getValidIdentifier(ProxoolConstants.ALIAS); final ObjectName objectName = ProxoolJMXHelper.getObjectName(alias); final AttributeList attributes = this.mBeanServer.getAttributes(objectName, new String[]{ fatalSQLAttribute, aliasAttribute }); String fatalSqlValue = null; String aliasValue = null; Iterator attributeIterator = attributes.iterator(); while (attributeIterator.hasNext()) { Attribute attribute = (Attribute) attributeIterator.next(); if (attribute.getName().equals(aliasAttribute)) { aliasValue = (String) attribute.getValue(); } else if (attribute.getName().equals(fatalSQLAttribute)) { fatalSqlValue = (String) attribute.getValue(); } } assertNotNull("The value for the alias attribute is missing.", aliasValue); assertNotNull("The value for the fatalSQLException attribute is missing.", fatalSqlValue); assertTrue("Expeted alias to have value '" + aliasValue + "' but the value was '" + aliasValue + ".", aliasValue.equals(alias)); assertTrue("Expexted fatalSQLException to have value '" + alias + "' but the value was '" + fatalSqlValue + ".", fatalSqlValue.equals(alias)); ProxoolFacade.removeConnectionPool(alias); } /** * Test that an attribute can be fetched from the MBean. * @throws java.lang.Exception if an error occours. */ public void testSetAttribute() throws Exception { String alias = "testSetAttribute"; createBasicPool(alias); final ObjectName objectName = ProxoolJMXHelper.getObjectName(alias); final String fatalSQLAttributeName = ProxoolJMXHelper.getValidIdentifier(ProxoolConstants.FATAL_SQL_EXCEPTION); final String newValue = "dingo"; this.mBeanServer.setAttribute(objectName, new Attribute(fatalSQLAttributeName, newValue)); String fatalSQLAttribtueValue = (String) mBeanServer.getAttribute(objectName, fatalSQLAttributeName); // check that value vas registered by the bean. assertTrue("Expexted fatalSQLException JMX attribtue to have value '" + newValue + "' but the value was '" + fatalSQLAttribtueValue + "'.", fatalSQLAttribtueValue.equals(newValue)); // check that the bean updated the pool. final String proxoolProopertyValue = (String) ProxoolFacade.getConnectionPoolDefinition(alias) .getFatalSqlExceptions().toArray()[0]; assertTrue("Expexted fatal-sql-exception Proxool property to have value '" + newValue + "' but the value was '" + proxoolProopertyValue + "'.", proxoolProopertyValue.equals(newValue)); // check that string properites can be deleted. this.mBeanServer.setAttribute(objectName, new Attribute(fatalSQLAttributeName, "")); fatalSQLAttribtueValue = (String) mBeanServer.getAttribute(objectName, fatalSQLAttributeName); assertTrue("Expexted fatal-sql-exception Proxool property to be empty " + " but the value was '" + fatalSQLAttribtueValue + "'.", "".equals(fatalSQLAttribtueValue)); ProxoolFacade.removeConnectionPool(alias); } public void testSetAttributes() throws Exception { String alias = "testSetAttributes"; createBasicPool(alias); final ObjectName objectName = ProxoolJMXHelper.getObjectName(alias); final String fatalSQLAttributeName = ProxoolJMXHelper.getValidIdentifier(ProxoolConstants.FATAL_SQL_EXCEPTION); final String testSQLAttributeName = ProxoolJMXHelper.getValidIdentifier(ProxoolConstants.HOUSE_KEEPING_TEST_SQL); final String newValue = "dingo"; // test when updated through JMX. final AttributeList attributeList = new AttributeList(); attributeList.add(new Attribute(fatalSQLAttributeName, newValue)); attributeList.add(new Attribute(testSQLAttributeName, newValue)); this.mBeanServer.setAttributes(objectName, attributeList); final String fatalSQLAttribtueValue = (String) mBeanServer.getAttribute(objectName, fatalSQLAttributeName); final String testSQLAttribtueValue = (String) mBeanServer.getAttribute(objectName, testSQLAttributeName); // check that values vas registered by the bean. assertTrue("Expexted fatalSQLException JMX attribtue to have value '" + newValue + "' but the value was '" + fatalSQLAttribtueValue + "'.", fatalSQLAttribtueValue.equals(newValue)); assertTrue("Expexted housekeeperTestSQL JMX attribtue to have value '" + newValue + "' but the value was '" + testSQLAttribtueValue + "'.", testSQLAttribtueValue.equals(newValue)); // check that the bean updated the pool. final String fatalSQLProxoolPropertyValue = (String) ProxoolFacade.getConnectionPoolDefinition(alias) .getFatalSqlExceptions().toArray()[0]; final String testSQLProxoolPropertyValue = ProxoolFacade.getConnectionPoolDefinition(alias) .getHouseKeepingTestSql(); assertTrue("Expexted fatal-sql-exception Proxool property to have value '" + newValue + "' but the value was '" + fatalSQLProxoolPropertyValue + ".", fatalSQLProxoolPropertyValue.equals(newValue)); assertTrue("Expexted housekeeper-test-sql Proxool property to have value '" + newValue + "' but the value was '" + testSQLProxoolPropertyValue + ".", testSQLProxoolPropertyValue.equals(newValue)); ProxoolFacade.removeConnectionPool(alias); } public void testInvokeShutown() throws Exception { final String alias = "testInvokeShutown"; createBasicPool(alias); final ObjectName objectName = ProxoolJMXHelper.getObjectName(alias); this.mBeanServer.invoke(objectName, "shutdown", new Object[0], new String[0]); try { ProxoolFacade.removeConnectionPool(alias); fail("Removal of pool alias should have failed, because it should have already be removed."); } catch (ProxoolException e) { // we want this } } public void testNotification() throws Exception { String alias = "testNotification"; Properties info = createBasicPool(alias); final NotificationListener notificationListener = new TestNotificationListener(); final ObjectName objectName = ProxoolJMXHelper.getObjectName(alias); this.mBeanServer.addNotificationListener(objectName, notificationListener, getFilter(), notificationListener); // test when updated through JMX. this.mBeanServer.setAttribute(objectName, new Attribute(ProxoolJMXHelper.getValidIdentifier(ProxoolConstants.FATAL_SQL_EXCEPTION), "dingo")); assertTrue("We did not get notified when updating through JMX.", this.notified); this.notified = false; // test when updated through ProxoolFacade info = (Properties) info.clone(); info.put(ProxoolConstants.MAXIMUM_CONNECTION_COUNT, "1"); ProxoolFacade.updateConnectionPool(ProxoolConstants.PROPERTY_PREFIX + alias, info); assertTrue("We did not get notified when updating through ProxoolFacade.", this.notified); ProxoolFacade.removeConnectionPool(alias); } private class TestNotificationListener implements NotificationListener { public void handleNotification(Notification notification, Object handBack) { if (handBack.equals(this)) { notified = true; } else { fail("Got notification with unknown handback."); } } } private NotificationFilter getFilter() { final NotificationFilterSupport notificationFilter = new NotificationFilterSupport(); notificationFilter.enableType(ConnectionPoolMBean.NOTIFICATION_TYPE_DEFINITION_UPDATED); return notificationFilter; } /** * Calls {@link org.logicalcobwebs.proxool.AbstractProxoolTest#setUp} * @see junit.framework.TestCase#setUp */ protected void setUp() throws Exception { this.notified = false; Class.forName(ProxoolDriver.class.getName()); this.mBeanServer = MBeanServerFactory.createMBeanServer(); super.setUp(); } /** * Calls {@link org.logicalcobwebs.proxool.AbstractProxoolTest#tearDown} * @see junit.framework.TestCase#setUp */ protected void tearDown() throws Exception { MBeanServerFactory.releaseMBeanServer(this.mBeanServer); this.mBeanServer = null; super.tearDown(); } } /* Revision history: $Log: ConnectionPoolMBeanTest.java,v $ Revision 1.10 2003/10/20 07:40:44 chr32 Improved tests. Revision 1.9 2003/05/06 23:17:12 chr32 Moving JMX tests back in from sandbox. Revision 1.1 2003/03/07 16:35:18 billhorsman moved jmx stuff into sandbox until it is tested Revision 1.7 2003/03/04 10:58:45 billhorsman checkstyle Revision 1.6 2003/03/04 10:24:41 billhorsman removed try blocks around each test Revision 1.5 2003/03/03 17:09:09 billhorsman all tests now extend AbstractProxoolTest Revision 1.4 2003/03/03 11:12:06 billhorsman fixed licence Revision 1.3 2003/03/01 15:27:25 billhorsman checkstyle Revision 1.2 2003/02/28 12:53:59 billhorsman move database to db directory and use constants where possible Revision 1.1 2003/02/26 19:03:43 chr32 Init rev. */ ././@LongLink 0000000 0000000 0000000 00000000171 00000000000 011564 L ustar root root libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/jmx/MultipleAgentsConnectionPoolMBeanTest.java libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/jmx/MultipleAgentsConnecti0000644 0001750 0001750 00000010674 10730503131 033715 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.admin.jmx; import org.logicalcobwebs.proxool.ProxoolConstants; import org.logicalcobwebs.proxool.ProxoolDriver; import org.logicalcobwebs.proxool.TestConstants; import org.logicalcobwebs.proxool.TestHelper; import org.logicalcobwebs.proxool.ProxoolFacade; import javax.management.MBeanServer; import javax.management.MBeanServerFactory; import javax.management.ObjectName; import java.sql.DriverManager; import java.sql.SQLException; import java.util.Properties; /** * Test {@link org.logicalcobwebs.proxool.admin.jmx.ConnectionPoolMBean} when JMX is configured for multiple agents. * * @version $Revision: 1.1 $, $Date: 2003/10/20 07:40:44 $ * @author Christian Nedregaard (christian_nedregaard@email.com) * @author $Author: chr32 $ (current maintainer) * @since Proxool 0.8 */ public class MultipleAgentsConnectionPoolMBeanTest extends AbstractJMXTest { private static final String AGENT1_DOMAIN = "testAgent1"; private static final String AGENT2_DOMAIN = "testAgent2"; private MBeanServer mBeanServer1; private MBeanServer mBeanServer2; private String mBeanServer1Id; private String mBeanServer2Id; /** * @see junit.framework.TestCase#TestCase(java.lang.String) */ public MultipleAgentsConnectionPoolMBeanTest(String s) { super(s); } /** * Test that pools can be regisered for multiple agents. * @throws Exception if the test fails in an unexpected way. */ public void testMultipleAgents() throws Exception { final String alias = "testMultipleAgents"; createMutipleAgentBasicPool(alias); final ObjectName objectName = ProxoolJMXHelper.getObjectName(alias); final String fatalSQLAttributeName = ProxoolJMXHelper.getValidIdentifier(ProxoolConstants.FATAL_SQL_EXCEPTION); String fatalSQLAttribtueValue = (String) mBeanServer1.getAttribute(objectName, fatalSQLAttributeName); assertTrue("Agent " + AGENT1_DOMAIN + " could not find " + fatalSQLAttribtueValue + " attribute.", fatalSQLAttribtueValue != null && fatalSQLAttribtueValue.trim().length() > 0); fatalSQLAttribtueValue = (String) mBeanServer2.getAttribute(objectName, fatalSQLAttributeName); assertTrue("Agent " + AGENT2_DOMAIN + " could not find " + fatalSQLAttribtueValue + " attribute.", fatalSQLAttribtueValue != null && fatalSQLAttribtueValue.trim().length() > 0); ProxoolFacade.removeConnectionPool(alias); } private Properties createMutipleAgentBasicPool(String alias) throws SQLException { final String url = TestHelper.buildProxoolUrl(alias, TestConstants.HYPERSONIC_DRIVER, TestConstants.HYPERSONIC_TEST_URL); final Properties info = createBasicProperties(alias); info.setProperty(ProxoolConstants.JMX_AGENT_PROPERTY, mBeanServer1Id + ", " + mBeanServer2Id); DriverManager.getConnection(url, info).close(); return info; } /** * Calls {@link org.logicalcobwebs.proxool.AbstractProxoolTest#setUp} * @see junit.framework.TestCase#setUp */ protected void setUp() throws Exception { Class.forName(ProxoolDriver.class.getName()); this.mBeanServer1 = MBeanServerFactory.createMBeanServer(AGENT1_DOMAIN); this.mBeanServer1Id = this.mBeanServer1.getAttribute( new ObjectName("JMImplementation:type=MBeanServerDelegate"), "MBeanServerId").toString(); this.mBeanServer2 = MBeanServerFactory.createMBeanServer(AGENT2_DOMAIN); this.mBeanServer2Id = this.mBeanServer2.getAttribute( new ObjectName("JMImplementation:type=MBeanServerDelegate"), "MBeanServerId").toString(); super.setUp(); } /** * Calls {@link org.logicalcobwebs.proxool.AbstractProxoolTest#tearDown} * @see junit.framework.TestCase#setUp */ protected void tearDown() throws Exception { MBeanServerFactory.releaseMBeanServer(this.mBeanServer1); MBeanServerFactory.releaseMBeanServer(this.mBeanServer2); this.mBeanServer1 = null; this.mBeanServer2 = null; super.tearDown(); } } /* Revision history: $Log: MultipleAgentsConnectionPoolMBeanTest.java,v $ Revision 1.1 2003/10/20 07:40:44 chr32 Improved tests. */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/AllTests.java 0000644 0001750 0001750 00000003673 10730503131 031153 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.admin; import junit.extensions.TestSetup; import junit.framework.Test; import junit.framework.TestSuite; import org.logicalcobwebs.proxool.GlobalTest; /** * Run all in admin package tests * * @version $Revision: 1.5 $, $Date: 2003/03/07 16:35:09 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.7 */ public class AllTests { /** * Create a composite test of all admin package tests * @return test suite */ public static Test suite() { TestSuite suite = new TestSuite(); suite.addTestSuite(StatisticsListenerTest.class); suite.addTestSuite(StatisticsTest.class); suite.addTestSuite(SnapshotTest.class); // create a wrapper for global initialization code. TestSetup wrapper = new TestSetup(suite) { public void setUp() throws Exception { GlobalTest.globalSetup(); } }; return wrapper; } } /* Revision history: $Log: AllTests.java,v $ Revision 1.5 2003/03/07 16:35:09 billhorsman moved jmx stuff into sandbox until it is tested Revision 1.4 2003/03/03 11:12:05 billhorsman fixed licence Revision 1.3 2003/02/26 19:03:08 chr32 Added suite for JMX tests. Revision 1.2 2003/02/26 11:53:17 billhorsman added StatisticsTest and SnapshotTest Revision 1.1 2003/02/20 00:33:15 billhorsman renamed monitor package -> admin Revision 1.3 2003/02/19 23:36:50 billhorsman renamed monitor package to admin Revision 1.2 2003/02/19 15:14:28 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.1 2003/02/07 15:10:36 billhorsman new admin tests */ ././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/SnapshotResultMonitor.java libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/SnapshotResultMonitor.java0000644 0001750 0001750 00000004053 10730503131 033757 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.admin; import org.logicalcobwebs.proxool.ProxoolFacade; import org.logicalcobwebs.proxool.ResultMonitor; /** * A ResultMonitor specifically for Snapshots * * @version $Revision: 1.4 $, $Date: 2003/03/03 11:12:05 $ * @author bill * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.8 */ public abstract class SnapshotResultMonitor extends ResultMonitor { private SnapshotIF snapshot; private String alias; /** * @param alias so we can lookup the latest {@link SnapshotIF snapshot} */ public SnapshotResultMonitor(String alias) { this.alias = alias; } /** * Passes the latest snapshot to {@link #check(org.logicalcobwebs.proxool.admin.SnapshotIF) check}. * @return {@link #SUCCESS} or {@link #TIMEOUT} * @throws Exception if anything goes wrong */ public boolean check() throws Exception { snapshot = ProxoolFacade.getSnapshot(alias); return check(snapshot); } /** * Override this with your specific check * @param snapshot the latest snapshot * @return true if the result has happened, else false * @throws Exception if anything goes wrong */ public abstract boolean check(SnapshotIF snapshot) throws Exception; /** * Get the snapshot used in the most recent {@link #check(org.logicalcobwebs.proxool.admin.SnapshotIF) check} * @return snapshot */ public SnapshotIF getSnapshot() { return snapshot; } } /* Revision history: $Log: SnapshotResultMonitor.java,v $ Revision 1.4 2003/03/03 11:12:05 billhorsman fixed licence Revision 1.3 2003/03/01 15:27:24 billhorsman checkstyle Revision 1.2 2003/03/01 15:22:50 billhorsman doc Revision 1.1 2003/03/01 15:14:14 billhorsman new ResultMonitor to help cope with test threads */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/SnapshotTest.java 0000644 0001750 0001750 00000014516 10730503130 032054 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.admin; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.logicalcobwebs.proxool.AbstractProxoolTest; import org.logicalcobwebs.proxool.ConnectionInfoIF; import org.logicalcobwebs.proxool.ProxoolConstants; import org.logicalcobwebs.proxool.ProxoolFacade; import org.logicalcobwebs.proxool.TestConstants; import org.logicalcobwebs.proxool.TestHelper; import java.sql.Connection; import java.sql.DriverManager; import java.sql.Statement; import java.util.Properties; /** * Test {@link SnapshotIF} * * @version $Revision: 1.14 $, $Date: 2006/01/18 14:40:05 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.7 */ public class SnapshotTest extends AbstractProxoolTest { private static final Log LOG = LogFactory.getLog(SnapshotTest.class); /** * @see junit.framework.TestCase#TestCase */ public SnapshotTest(String s) { super(s); } /** * Test whether the statistics we get back are roughly right. */ public void testSnapshot() throws Exception { String testName = "snapshot"; final String alias = testName; String url = TestHelper.buildProxoolUrl(alias, TestConstants.HYPERSONIC_DRIVER, TestConstants.HYPERSONIC_TEST_URL); Properties info = new Properties(); info.setProperty(ProxoolConstants.USER_PROPERTY, TestConstants.HYPERSONIC_USER); info.setProperty(ProxoolConstants.PASSWORD_PROPERTY, TestConstants.HYPERSONIC_PASSWORD); info.setProperty(ProxoolConstants.STATISTICS_PROPERTY, "10s,15s"); info.setProperty(ProxoolConstants.MINIMUM_CONNECTION_COUNT_PROPERTY, "1"); info.setProperty(ProxoolConstants.TRACE_PROPERTY, "true"); // We don't test whether anything is logged, but this line should make something appear info.setProperty(ProxoolConstants.STATISTICS_LOG_LEVEL_PROPERTY, ProxoolConstants.STATISTICS_LOG_LEVEL_DEBUG); // Register pool ProxoolFacade.registerConnectionPool(url, info); { Connection connection = DriverManager.getConnection(url); connection.createStatement().execute(TestConstants.HYPERSONIC_TEST_SQL); connection.close(); SnapshotIF snapshot = ProxoolFacade.getSnapshot(alias, true); assertEquals("servedCount", 1L, snapshot.getServedCount()); assertEquals("refusedCount", 0L, snapshot.getRefusedCount()); assertEquals("activeConnectionCount", 0, snapshot.getActiveConnectionCount()); ConnectionInfoIF[] connectionInfos = snapshot.getConnectionInfos(); assertTrue("connectionInfos.length != 0", connectionInfos.length != 0); assertEquals("connectionInfos activeCount", 0, getCount(connectionInfos, ConnectionInfoIF.STATUS_ACTIVE)); assertEquals("connectionInfos sql count", 1, connectionInfos[0].getSqlCalls().length); assertEquals("connectionInfos lastSql", TestConstants.HYPERSONIC_TEST_SQL, connectionInfos[0].getSqlCalls()[0].replace(';', ' ').trim()); } { Connection connection = DriverManager.getConnection(url); connection.createStatement().execute(TestConstants.HYPERSONIC_TEST_SQL); connection.createStatement().execute(TestConstants.HYPERSONIC_TEST_SQL_2); SnapshotIF snapshot = ProxoolFacade.getSnapshot(alias, true); assertEquals("servedCount", 2L, snapshot.getServedCount()); assertEquals("refusedCount", 0L, snapshot.getRefusedCount()); assertEquals("activeConnectionCount", 1, snapshot.getActiveConnectionCount()); ConnectionInfoIF[] connectionInfos = snapshot.getConnectionInfos(); assertTrue("connectionInfos.length != 0", connectionInfos.length != 0); assertEquals("connectionInfos activeCount", 1, getCount(connectionInfos, ConnectionInfoIF.STATUS_ACTIVE)); assertEquals("connectionInfos sql count", 2, connectionInfos[0].getSqlCalls().length); assertEquals("connectionInfos lastSql", TestConstants.HYPERSONIC_TEST_SQL, connectionInfos[0].getSqlCalls()[0].replace(';', ' ').trim()); assertEquals("connectionInfos lastSql", TestConstants.HYPERSONIC_TEST_SQL_2, connectionInfos[0].getSqlCalls()[1].replace(';', ' ').trim()); connection.close(); } } private int getCount(ConnectionInfoIF[] connectionInfos, int status) { int count = 0; for (int i = 0; i < connectionInfos.length; i++) { if (connectionInfos[i].getStatus() == status) { count++; } } return count; } } /* Revision history: $Log: SnapshotTest.java,v $ Revision 1.14 2006/01/18 14:40:05 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.13 2005/10/07 08:13:46 billhorsman Test new sqlCalls property of snapshot Revision 1.12 2003/03/10 23:46:43 billhorsman checkstyle Revision 1.11 2003/03/06 14:25:53 billhorsman fix for threading Revision 1.10 2003/03/06 11:31:17 billhorsman fix for unlikely prototyper situation Revision 1.8 2003/03/04 10:58:44 billhorsman checkstyle Revision 1.7 2003/03/04 10:24:40 billhorsman removed try blocks around each test Revision 1.6 2003/03/03 17:09:08 billhorsman all tests now extend AbstractProxoolTest Revision 1.5 2003/03/03 11:12:05 billhorsman fixed licence Revision 1.4 2003/03/01 15:27:25 billhorsman checkstyle Revision 1.3 2003/02/27 18:01:48 billhorsman completely rethought the test structure. it's now more obvious. no new tests yet though. Revision 1.2 2003/02/26 16:05:51 billhorsman widespread changes caused by refactoring the way we update and redefine pool definitions. Revision 1.1 2003/02/20 00:33:15 billhorsman renamed monitor package -> admin Revision 1.3 2003/02/19 23:36:50 billhorsman renamed monitor package to admin Revision 1.2 2003/02/19 15:14:29 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.1 2003/02/07 17:28:36 billhorsman *** empty log message *** */ ././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/StatisticsListenerTest.java libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/StatisticsListenerTest.jav0000644 0001750 0001750 00000014432 10730503131 033752 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.admin; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.logicalcobwebs.proxool.AbstractProxoolTest; import org.logicalcobwebs.proxool.ProxoolConstants; import org.logicalcobwebs.proxool.ProxoolFacade; import org.logicalcobwebs.proxool.TestConstants; import org.logicalcobwebs.proxool.TestHelper; import java.sql.DriverManager; import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Properties; /** * Test {@link StatisticsListenerIF} * * @version $Revision: 1.13 $, $Date: 2006/01/18 14:40:05 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.7 */ public class StatisticsListenerTest extends AbstractProxoolTest { private static final Log LOG = LogFactory.getLog(StatisticsListenerTest.class); /** * HH:mm:ss */ private static final DateFormat TIME_FORMAT = new SimpleDateFormat("mm:ss"); /** * @see junit.framework.TestCase#TestCase */ public StatisticsListenerTest(String s) { super(s); } /** * Can we listen to statistics */ public void testListener() throws Exception { String testName = "listener"; String alias = testName; String url = TestHelper.buildProxoolUrl(alias, TestConstants.HYPERSONIC_DRIVER, TestConstants.HYPERSONIC_TEST_URL); Properties info = new Properties(); info.setProperty(ProxoolConstants.USER_PROPERTY, TestConstants.HYPERSONIC_USER); info.setProperty(ProxoolConstants.PASSWORD_PROPERTY, TestConstants.HYPERSONIC_PASSWORD); info.setProperty(ProxoolConstants.STATISTICS_PROPERTY, "5s"); // We don't test whether anything is logged, but this line should make something appear info.setProperty(ProxoolConstants.STATISTICS_LOG_LEVEL_PROPERTY, ProxoolConstants.STATISTICS_LOG_LEVEL_DEBUG); // Register pool ProxoolFacade.registerConnectionPool(url, info); // Add listener TestListener testListener = new TestListener(); ProxoolFacade.addStatisticsListener(alias, testListener); Date lap0 = new Date(); // Wait for next statistics1 so we can guarantee that next set won't // be produced whilst we are building connection testListener.getNextStatistics(); Date lap1 = new Date(); DriverManager.getConnection(url).close(); Date lap2 = new Date(); StatisticsIF statistics1 = testListener.getNextStatistics(); Date lap3 = new Date(); StatisticsIF statistics2 = testListener.getNextStatistics(); Date lap4 = new Date(); StringBuffer detail = new StringBuffer(); detail.append("lap0:"); detail.append(TIME_FORMAT.format(lap0)); detail.append(", lap1:"); detail.append(TIME_FORMAT.format(lap1)); detail.append(", lap2:"); detail.append(TIME_FORMAT.format(lap2)); detail.append(", lap3:"); detail.append(TIME_FORMAT.format(lap3)); detail.append("("); detail.append(statistics1.getServedCount()); detail.append("), lap4:"); detail.append(TIME_FORMAT.format(lap4)); detail.append("("); detail.append(statistics2.getServedCount()); detail.append(")"); assertEquals("servedCount - " + detail, 1L, statistics1.getServedCount()); } class TestListener implements StatisticsListenerIF { private StatisticsIF statistics; private boolean somethingHappened; public void statistics(String alias, StatisticsIF statistics) { this.statistics = statistics; somethingHappened = true; } void reset() { statistics = null; somethingHappened = false; } public StatisticsIF getStatistics() { return statistics; } void waitForSomethingToHappen() { long start = System.currentTimeMillis(); while (!somethingHappened) { try { Thread.sleep(500); } catch (InterruptedException e) { LOG.error("Awoken", e); } if (System.currentTimeMillis() - start > 30000) { fail("Timeout waiting for something to happen"); } } } StatisticsIF getNextStatistics() { somethingHappened = false; waitForSomethingToHappen(); return statistics; } } } /* Revision history: $Log: StatisticsListenerTest.java,v $ Revision 1.13 2006/01/18 14:40:05 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.12 2003/09/05 16:27:27 billhorsman Better debug output. Revision 1.11 2003/03/04 10:58:44 billhorsman checkstyle Revision 1.10 2003/03/04 10:24:40 billhorsman removed try blocks around each test Revision 1.9 2003/03/03 17:09:08 billhorsman all tests now extend AbstractProxoolTest Revision 1.8 2003/03/03 11:12:05 billhorsman fixed licence Revision 1.7 2003/03/01 15:49:33 billhorsman fix Revision 1.6 2003/03/01 15:38:38 billhorsman better assert msg Revision 1.5 2003/03/01 15:27:25 billhorsman checkstyle Revision 1.4 2003/02/27 18:01:48 billhorsman completely rethought the test structure. it's now more obvious. no new tests yet though. Revision 1.3 2003/02/27 09:45:33 billhorsman sleep a little Revision 1.2 2003/02/26 16:05:51 billhorsman widespread changes caused by refactoring the way we update and redefine pool definitions. Revision 1.1 2003/02/20 00:33:15 billhorsman renamed monitor package -> admin Revision 1.5 2003/02/19 23:36:50 billhorsman renamed monitor package to admin Revision 1.4 2003/02/19 15:14:30 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.3 2003/02/07 17:28:23 billhorsman checkstyle and doc Revision 1.2 2003/02/07 15:11:33 billhorsman checkstyle Revision 1.1 2003/02/07 15:10:37 billhorsman new admin tests */ ././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/StatisticsResultMonitor.java libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/StatisticsResultMonitor.ja0000644 0001750 0001750 00000007131 10730503131 033763 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.admin; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.logicalcobwebs.proxool.ProxoolException; import org.logicalcobwebs.proxool.ProxoolFacade; import org.logicalcobwebs.proxool.ResultMonitor; /** * A ResultMonitor specifically for Snapshots * * @version $Revision: 1.10 $, $Date: 2006/01/18 14:40:06 $ * @author bill * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.8 */ public class StatisticsResultMonitor extends ResultMonitor { private static final Log LOG = LogFactory.getLog(StatisticsResultMonitor.class); private StatisticsIF statistics; private StatisticsIF oldStatistics; private String alias; private String token; /** * @param alias so we can lookup the latest {@link StatisticsIF statistics} * @param token so we can lookup the latest {@link StatisticsIF statistics} */ public StatisticsResultMonitor(String alias, String token) { this.alias = alias; this.token = token; setDelay(2000); } /** * waits for statistics * @return {@link #SUCCESS} or {@link #TIMEOUT} * @throws Exception if anything goes wrong */ public boolean check() throws Exception { statistics = ProxoolFacade.getStatistics(alias, token); if (statistics == null) { return false; } else if (oldStatistics == null) { return check(statistics); } else { if (!statistics.getStartDate().equals(oldStatistics.getStartDate())) { return check(statistics); } else { return false; } } } /** * This gets called when we get new statistics. By overriding this * method you get the option of rejecting these new statistics and * waiting for the next set * @param statistics the newly created statistics * @return true if we accept them, false if we want to wait for the next set * (if you don't override this it will return true) */ protected boolean check(StatisticsIF statistics) { return true; } public int getResult() throws ProxoolException { oldStatistics = statistics; return super.getResult(); } /** * Get the statistics used in the most recent {@link #check check} * @return snapshot */ public StatisticsIF getStatistics() { return statistics; } } /* Revision history: $Log: StatisticsResultMonitor.java,v $ Revision 1.10 2006/01/18 14:40:06 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.9 2003/03/06 22:39:05 billhorsman fix Revision 1.8 2003/03/06 22:28:32 billhorsman another go at statistics threading (in tests) Revision 1.7 2003/03/04 10:24:41 billhorsman removed try blocks around each test Revision 1.6 2003/03/03 11:12:06 billhorsman fixed licence Revision 1.5 2003/03/01 18:17:50 billhorsman arrffgh. fix, Revision 1.4 2003/03/01 16:53:07 billhorsman fix Revision 1.3 2003/03/01 16:38:40 billhorsman fix Revision 1.2 2003/03/01 16:18:31 billhorsman fix Revision 1.1 2003/03/01 16:07:26 billhorsman helper Revision 1.3 2003/03/01 15:27:24 billhorsman checkstyle Revision 1.2 2003/03/01 15:22:50 billhorsman doc Revision 1.1 2003/03/01 15:14:14 billhorsman new ResultMonitor to help cope with test threads */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/admin/StatisticsTest.java 0000644 0001750 0001750 00000015504 10730503131 032406 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.admin; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.logicalcobwebs.proxool.AbstractProxoolTest; import org.logicalcobwebs.proxool.ConnectionPoolDefinitionIF; import org.logicalcobwebs.proxool.ProxoolConstants; import org.logicalcobwebs.proxool.ProxoolFacade; import org.logicalcobwebs.proxool.ResultMonitor; import org.logicalcobwebs.proxool.TestConstants; import org.logicalcobwebs.proxool.TestHelper; import java.sql.DriverManager; import java.text.DecimalFormat; import java.util.Properties; /** * Test {@link StatisticsIF} * * @version $Revision: 1.22 $, $Date: 2006/01/18 14:40:06 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.7 */ public class StatisticsTest extends AbstractProxoolTest { private static final Log LOG = LogFactory.getLog(StatisticsTest.class); private static final DecimalFormat DECIMAL_FORMAT = new DecimalFormat("0.00"); /** * @see junit.framework.TestCase#TestCase */ public StatisticsTest(String s) { super(s); } /** * Test whether the statistics we get back are roughly right. */ public void testStatistics() throws Exception { String testName = "statistics"; String alias = testName; String url = TestHelper.buildProxoolUrl(alias, TestConstants.HYPERSONIC_DRIVER, TestConstants.HYPERSONIC_TEST_URL); Properties info = new Properties(); info.setProperty(ProxoolConstants.USER_PROPERTY, TestConstants.HYPERSONIC_USER); info.setProperty(ProxoolConstants.PASSWORD_PROPERTY, TestConstants.HYPERSONIC_PASSWORD); info.setProperty(ProxoolConstants.STATISTICS_PROPERTY, "10s,15s"); info.setProperty(ProxoolConstants.MINIMUM_CONNECTION_COUNT_PROPERTY, "1"); info.setProperty(ProxoolConstants.VERBOSE_PROPERTY, "true"); // We don't test whether anything is logged, but this line should make something appear info.setProperty(ProxoolConstants.STATISTICS_LOG_LEVEL_PROPERTY, ProxoolConstants.STATISTICS_LOG_LEVEL_DEBUG); // Register pool ProxoolFacade.registerConnectionPool(url, info); // Skip past the first set because they will probably be for only part // of the 10s period. StatisticsResultMonitor srm = new StatisticsResultMonitor(alias, "10s"); assertEquals("Timeout", ResultMonitor.SUCCESS, srm.getResult()); srm.getStatistics(); DriverManager.getConnection(url).close(); srm = new StatisticsResultMonitor(alias, "10s") { protected boolean check(StatisticsIF statistics) { return (statistics.getServedCount() == 1); } }; assertEquals("Timeout", ResultMonitor.SUCCESS, srm.getResult()); StatisticsIF statistics = srm.getStatistics(); assertEquals("servedCount", 1L, statistics.getServedCount()); assertEquals("servedPerSecond", 0.09, 0.11, statistics.getServedPerSecond()); assertEquals("refusedCount", 0L, statistics.getRefusedCount()); } public void testOverhead() throws Exception { String testName = "overhead"; String alias = testName; String url = TestHelper.buildProxoolUrl(alias, TestConstants.HYPERSONIC_DRIVER, TestConstants.HYPERSONIC_TEST_URL); Properties info = new Properties(); info.setProperty(ProxoolConstants.USER_PROPERTY, TestConstants.HYPERSONIC_USER); info.setProperty(ProxoolConstants.PASSWORD_PROPERTY, TestConstants.HYPERSONIC_PASSWORD); info.setProperty(ProxoolConstants.STATISTICS_PROPERTY, "10s"); info.setProperty(ProxoolConstants.MINIMUM_CONNECTION_COUNT_PROPERTY, "1"); // We don't test whether anything is logged, but this line should make something appear info.setProperty(ProxoolConstants.STATISTICS_LOG_LEVEL_PROPERTY, ProxoolConstants.STATISTICS_LOG_LEVEL_DEBUG); // Register pool ProxoolFacade.registerConnectionPool(url, info); ConnectionPoolDefinitionIF cpd = ProxoolFacade.getConnectionPoolDefinition(alias); Admin admin = new Admin(cpd); final int loops = 100000; long start = System.currentTimeMillis(); for (int i = 0; i < loops; i++) { admin.connectionReturned(10); } double avg = (double) (System.currentTimeMillis() - start) / (double) loops; LOG.info("Statistics take " + DECIMAL_FORMAT.format(avg * 1000) + " microseconds"); } } /* Revision history: $Log: StatisticsTest.java,v $ Revision 1.22 2006/01/18 14:40:06 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.21 2003/03/06 22:28:31 billhorsman another go at statistics threading (in tests) Revision 1.20 2003/03/06 12:45:06 billhorsman switch on verbose logging Revision 1.19 2003/03/06 10:37:41 billhorsman better timeout assertion Revision 1.18 2003/03/04 10:58:44 billhorsman checkstyle Revision 1.17 2003/03/04 10:24:41 billhorsman removed try blocks around each test Revision 1.16 2003/03/03 17:09:09 billhorsman all tests now extend AbstractProxoolTest Revision 1.15 2003/03/03 11:12:06 billhorsman fixed licence Revision 1.14 2003/03/03 09:10:41 billhorsman removed debug Revision 1.13 2003/03/02 01:16:37 billhorsman removed flakey average active time test Revision 1.12 2003/03/01 18:25:53 billhorsman *** empty log message *** Revision 1.11 2003/03/01 16:46:08 billhorsman debug Revision 1.10 2003/03/01 16:14:32 billhorsman debug Revision 1.9 2003/03/01 16:04:45 billhorsman fix Revision 1.8 2003/03/01 15:27:25 billhorsman checkstyle Revision 1.7 2003/02/28 12:36:33 billhorsman more robust waiting for statistics Revision 1.6 2003/02/28 12:23:59 billhorsman more robust waiting for statistics Revision 1.5 2003/02/27 18:01:49 billhorsman completely rethought the test structure. it's now more obvious. no new tests yet though. Revision 1.4 2003/02/26 23:45:18 billhorsman add some sleep Revision 1.3 2003/02/26 18:30:02 billhorsman test for stats overhead Revision 1.2 2003/02/26 16:05:51 billhorsman widespread changes caused by refactoring the way we update and redefine pool definitions. Revision 1.1 2003/02/20 00:33:15 billhorsman renamed monitor package -> admin Revision 1.3 2003/02/19 23:36:50 billhorsman renamed monitor package to admin Revision 1.2 2003/02/19 15:14:31 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.1 2003/02/07 17:28:36 billhorsman *** empty log message *** */ libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/ 0000755 0001750 0001750 00000000000 11054125603 030327 5 ustar twerner twerner libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/AllTests.java 0000644 0001750 0001750 00000004626 10730503130 032730 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.configuration; import junit.extensions.TestSetup; import junit.framework.Test; import junit.framework.TestSuite; import org.logicalcobwebs.proxool.GlobalTest; /** * Run all tests * * @version $Revision: 1.7 $, $Date: 2003/03/03 11:12:06 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ public class AllTests { /** * Create a composite test of all Proxool configuration tests. * * @return a composite test of all Proxool configuration tests. */ public static Test suite() { TestSuite suite = new TestSuite(); suite.addTestSuite(ConfiguratorTest.class); suite.addTestSuite(PropertyConfiguratorTest.class); suite.addTestSuite(JAXPConfiguratorTest.class); suite.addTestSuite(AvalonConfiguratorTest.class); // create a wrapper for global initialization code. TestSetup wrapper = new TestSetup(suite) { public void setUp() throws Exception { GlobalTest.globalSetup(); } }; return wrapper; } } /* Revision history: $Log: AllTests.java,v $ Revision 1.7 2003/03/03 11:12:06 billhorsman fixed licence Revision 1.6 2003/02/19 15:14:26 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.5 2002/12/26 11:35:32 billhorsman Added PropertyConfiguratorTest to test suite. Revision 1.4 2002/12/23 02:40:21 chr32 Doc. Revision 1.3 2002/12/18 03:13:51 chr32 Doc. Revision 1.2 2002/12/16 17:35:43 chr32 Removed redundant imports. Revision 1.1 2002/12/16 17:06:26 billhorsman new test structure Revision 1.7 2002/12/15 19:16:58 chr32 Added JAXPConfigurator test. Revision 1.6 2002/11/07 18:53:41 billhorsman slight improvement to setup Revision 1.5 2002/11/02 11:37:48 billhorsman New tests Revision 1.4 2002/10/28 21:37:54 billhorsman now allows for non-existent log4jPath Revision 1.3 2002/10/27 13:05:02 billhorsman checkstyle Revision 1.2 2002/10/27 12:03:33 billhorsman clear up of tests Revision 1.1 2002/10/25 10:41:07 billhorsman draft changes to test globalSetup */ ././@LongLink 0000000 0000000 0000000 00000000156 00000000000 011567 L ustar root root libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/AvalonConfiguratorTest.java libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/AvalonConfigurator0000644 0001750 0001750 00000021037 10730503130 034053 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.configuration; import org.apache.avalon.excalibur.component.DefaultRoleManager; import org.apache.avalon.excalibur.component.ExcaliburComponentManager; import org.apache.avalon.framework.configuration.Configuration; import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder; import org.apache.avalon.framework.context.DefaultContext; import org.apache.log.Hierarchy; import org.apache.log.LogTarget; import org.apache.log.Logger; import org.apache.log.Priority; import org.logicalcobwebs.proxool.AbstractProxoolTest; import org.logicalcobwebs.proxool.ProxoolException; import org.logicalcobwebs.proxool.ProxoolFacade; import org.logicalcobwebs.proxool.TestHelper; import java.io.File; /** * Tests that the AvalonConfgiuration works. * * @version $Revision: 1.10 $, $Date: 2003/03/04 10:58:45 $ * @author Christian Nedregaard (christian_nedregaard@email.com) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.6 */ public class AvalonConfiguratorTest extends AbstractProxoolTest { private ExcaliburComponentManager componentManager; /** * @see junit.framework.TestCase#TestCase */ public AvalonConfiguratorTest(String name) { super(name); } /** * Test that the configuration succeds and that all expected properties * has been received by Proxool. The configuration file does not use namspaces. * @throws org.apache.avalon.framework.component.ComponentException if the configuration fails. * @throws java.sql.SQLException if ProxoolFacade operation fails. */ public void testNoNamspaces() throws Exception { initializeAvalon("src/java-test/org/logicalcobwebs/proxool/configuration/role.conf", "src/java-test/org/logicalcobwebs/proxool/configuration/component.conf"); this.componentManager.lookup(AvalonConfigurator.ROLE); try { TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("avalon-test")); } catch (ProxoolException e) { throw e; } try { TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("avalon-test-2")); } catch (ProxoolException e) { throw e; } this.componentManager.dispose(); } /** * Test that the configuration succeds and that all expected properties * has been received by Proxool. The configuration file uses namspaces. * @throws Exception if the test is interrupted. */ public void testWithNamespaces() throws Exception { initializeAvalon("src/java-test/org/logicalcobwebs/proxool/configuration/role.conf", "src/java-test/org/logicalcobwebs/proxool/configuration/component-ns.conf"); this.componentManager.lookup(AvalonConfigurator.ROLE); try { TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("avalon-test-ns")); } catch (ProxoolException e) { throw e; } try { TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("avalon-test-ns-2")); } catch (ProxoolException e) { throw e; } ProxoolFacade.removeConnectionPool("avalon-test-ns"); ProxoolFacade.removeConnectionPool("avalon-test-ns-2"); this.componentManager.dispose(); } /** * Test that a configurator that does not have close-on-dispose="false" * closes the pools it has configured when it is disposed. * @throws Exception if the test is interrupted. */ public void testDisposeOnClose() throws Exception { initializeAvalon("src/java-test/org/logicalcobwebs/proxool/configuration/role.conf", "src/java-test/org/logicalcobwebs/proxool/configuration/component.conf"); this.componentManager.lookup(AvalonConfigurator.ROLE); this.componentManager.dispose(); try { ProxoolFacade.getConnectionPoolDefinition("avalon-test"); fail("ProxoolFacade found pool 'avalon-test' but we expected the configurator to have removed it."); } catch (ProxoolException e) { // This is what we want. } try { ProxoolFacade.getConnectionPoolDefinition("avalon-test-2"); fail("ProxoolFacade found pool 'avalon-test-2' but we expected the configurator to have removed it."); } catch (ProxoolException e) { // This is what we want. } } /** * Test that a configurator that does have close-on-dispose="false" * does not close the pools it has configured when it is disposed. * @throws Exception if the test is interrupted. */ public void testNotDisposeOnClose() throws Exception { initializeAvalon("src/java-test/org/logicalcobwebs/proxool/configuration/role.conf", "src/java-test/org/logicalcobwebs/proxool/configuration/component-ns.conf"); this.componentManager.lookup(AvalonConfigurator.ROLE); this.componentManager.dispose(); try { ProxoolFacade.getConnectionPoolDefinition("avalon-test-ns"); } catch (ProxoolException e) { fail("ProxoolFacade did not find pool 'avalon-test-ns' but we didn't expect the configurator to have removed it."); } try { ProxoolFacade.getConnectionPoolDefinition("avalon-test-ns-2"); } catch (ProxoolException e) { fail("ProxoolFacade did not find pool 'avalon-ns-test-2' but we didn't expect the configurator to have removed it."); } ProxoolFacade.removeConnectionPool("avalon-test-ns"); ProxoolFacade.removeConnectionPool("avalon-test-ns-2"); } private void initializeAvalon(String roleFile, String componentFile) throws Exception { // create a Avalon logger final LogTarget logTarget = new LogKitTargetAdapter(); final Logger rootLogger = Hierarchy.getDefaultHierarchy().getLoggerFor("root"); rootLogger.unsetLogTargets(); rootLogger.setLogTargets(new LogTarget[]{logTarget}); rootLogger.setPriority(Priority.WARN); final DefaultConfigurationBuilder builder = new DefaultConfigurationBuilder(true); // create component configuration final Configuration componentConfiguration = builder.buildFromFile(new File(componentFile)); // create role configuration final Configuration roleConfiguration = builder.buildFromFile(new File(roleFile)); // create and configure role and component managers. this.componentManager = new ExcaliburComponentManager(); this.componentManager.setLogger(rootLogger.getChildLogger(ExcaliburComponentManager.class.getName())); DefaultRoleManager roleManager = new DefaultRoleManager(); roleManager.setLogger(rootLogger.getChildLogger(DefaultRoleManager.class.getName())); roleManager.configure(roleConfiguration); componentManager.contextualize(new DefaultContext()); componentManager.setRoleManager(roleManager); componentManager.configure(componentConfiguration); componentManager.initialize(); } } /* Revision history: $Log: AvalonConfiguratorTest.java,v $ Revision 1.10 2003/03/04 10:58:45 billhorsman checkstyle Revision 1.9 2003/03/04 10:24:41 billhorsman removed try blocks around each test Revision 1.8 2003/03/03 17:09:12 billhorsman all tests now extend AbstractProxoolTest Revision 1.7 2003/03/03 11:12:06 billhorsman fixed licence Revision 1.6 2003/03/01 15:27:25 billhorsman checkstyle Revision 1.5 2003/02/27 18:01:49 billhorsman completely rethought the test structure. it's now more obvious. no new tests yet though. Revision 1.4 2003/02/19 16:52:00 chr32 Added tests for close-on-dispose functionality. Revision 1.3 2003/02/19 15:14:26 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.2 2002/12/23 02:48:07 chr32 Checkstyle. Revision 1.1 2002/12/23 02:40:49 chr32 Init rev. Revision 1.5 2002/12/18 03:13:00 chr32 Added tests for xml validation. Revision 1.4 2002/12/16 17:06:41 billhorsman new test structure Revision 1.3 2002/12/16 02:35:40 chr32 Updated to new driver-properties xml format. Revision 1.2 2002/12/15 19:41:26 chr32 Style fixes. Revision 1.1 2002/12/15 19:10:49 chr32 Init rev. */ ././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/ConfiguratorTest.java libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/ConfiguratorTest.j0000644 0001750 0001750 00000010356 10730503130 034004 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.configuration; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.logicalcobwebs.proxool.AbstractProxoolTest; import org.logicalcobwebs.proxool.ConnectionPoolDefinitionIF; import org.logicalcobwebs.proxool.ProxoolConstants; import org.logicalcobwebs.proxool.ProxoolFacade; import org.logicalcobwebs.proxool.TestConstants; import org.logicalcobwebs.proxool.TestHelper; import java.util.Properties; /** * Tests that the programatic configuration of Proxool works. * * @version $Revision: 1.16 $, $Date: 2006/01/18 14:40:06 $ * @author Bill Horsman (bill@logicalcobwebs.co.uk) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.5 */ public class ConfiguratorTest extends AbstractProxoolTest { private static final Log LOG = LogFactory.getLog(ConfiguratorTest.class); private static final String TEST_TABLE = "test"; /** * @see junit.framework.TestCase#TestCase */ public ConfiguratorTest(String name) { super(name); } public void testConfigurator() throws Exception { String testName = "configurator"; String alias = testName; String url = TestHelper.buildProxoolUrl(alias, TestConstants.HYPERSONIC_DRIVER, TestConstants.HYPERSONIC_TEST_URL); Properties info = new Properties(); info.setProperty(ProxoolConstants.USER_PROPERTY, TestConstants.HYPERSONIC_USER); info.setProperty(ProxoolConstants.PASSWORD_PROPERTY, TestConstants.HYPERSONIC_PASSWORD); ProxoolFacade.registerConnectionPool(url, info); Properties newInfo = new Properties(); newInfo.setProperty(ProxoolConstants.PROTOTYPE_COUNT_PROPERTY, "3"); ProxoolFacade.updateConnectionPool(url, newInfo); final ConnectionPoolDefinitionIF cpd = ProxoolFacade.getConnectionPoolDefinition(alias); assertNotNull("definition is null", cpd); assertEquals("prototypeCount", 3, cpd.getPrototypeCount()); } } /* Revision history: $Log: ConfiguratorTest.java,v $ Revision 1.16 2006/01/18 14:40:06 billhorsman Unbundled Jakarta's Commons Logging. Revision 1.15 2003/03/04 10:24:41 billhorsman removed try blocks around each test Revision 1.14 2003/03/03 17:09:17 billhorsman all tests now extend AbstractProxoolTest Revision 1.13 2003/03/03 11:12:06 billhorsman fixed licence Revision 1.12 2003/02/27 18:01:49 billhorsman completely rethought the test structure. it's now more obvious. no new tests yet though. Revision 1.11 2003/02/19 15:14:26 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.10 2003/02/07 10:11:35 billhorsman fix Revision 1.9 2003/02/07 09:35:52 billhorsman changed alias for testConfigurator Revision 1.8 2003/02/06 17:41:03 billhorsman now uses imported logging Revision 1.7 2003/01/22 17:35:03 billhorsman checkstyle Revision 1.6 2003/01/18 15:13:14 billhorsman Signature changes (new ProxoolException thrown) on the ProxoolFacade API. Revision 1.5 2003/01/17 00:38:12 billhorsman wide ranging changes to clarify use of alias and url - this has led to some signature changes (new exceptions thrown) on the ProxoolFacade API. Revision 1.4 2002/12/26 11:35:02 billhorsman Removed test regarding property configurator. Revision 1.3 2002/12/16 17:06:53 billhorsman new test structure Revision 1.2 2002/12/15 19:41:28 chr32 Style fixes. Revision 1.1 2002/12/15 19:10:49 chr32 Init rev. Revision 1.4 2002/12/04 13:20:11 billhorsman ConfigurationListenerIF test Revision 1.3 2002/11/09 16:00:45 billhorsman fix doc Revision 1.2 2002/11/02 13:57:34 billhorsman checkstyle Revision 1.1 2002/11/02 11:37:48 billhorsman New tests Revision 1.4 2002/10/29 23:17:38 billhorsman Cleaned up SQL stuff Revision 1.3 2002/10/27 13:05:02 billhorsman checkstyle Revision 1.2 2002/10/27 12:03:33 billhorsman clear up of tests Revision 1.1 2002/10/25 10:41:07 billhorsman draft changes to test globalSetup */ ././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/JAXPConfiguratorTest.java libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/JAXPConfiguratorTe0000644 0001750 0001750 00000020577 10730503130 033676 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.configuration; import org.logicalcobwebs.proxool.AbstractProxoolTest; import org.logicalcobwebs.proxool.ProxoolConstants; import org.logicalcobwebs.proxool.ProxoolException; import org.logicalcobwebs.proxool.ProxoolFacade; import org.logicalcobwebs.proxool.TestHelper; import org.xml.sax.InputSource; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.sql.DriverManager; import java.sql.SQLException; /** * Tests that the JAXPConfgiuration works in various scenarios. * This is also a test of the {@link XMLConfigurator}, as it is delegated to. * * @version $Revision: 1.16 $, $Date: 2003/08/30 14:54:23 $ * @author Christian Nedregaard (christian_nedregaard@email.com) * @author $Author: billhorsman $ (current maintainer) * @since Proxool 0.6 */ public class JAXPConfiguratorTest extends AbstractProxoolTest { /** * @see junit.framework.TestCase#TestCase */ public JAXPConfiguratorTest(String name) { super(name); } /** * Test that the confguration succeds and that all expected properties * has been received by Proxool. This test is done with a * xml without namespaces and validiation. * @throws ProxoolException if the configuration fails. * @throws SQLException if ProxoolFacade operation fails. */ public void testNoNamspaces() throws ProxoolException, SQLException { final String xmlFile = "src/java-test/org/logicalcobwebs/proxool/configuration/test-no-ns.xml"; JAXPConfigurator.configure(xmlFile, false); try { assertNotNull("2nd (deeply nested) pool was not configured.", ProxoolFacade.getConnectionPoolDefinition("xml-test-2")); } catch (ProxoolException e) { fail("2nd (deeply nested) pool was not configured."); } TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("xml-test")); TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("xml-test-2")); } /** * Test that the confguration succeds and that all expected properties * has been received by Proxool. This test is done with a * xml with namespaces and without validiation. * @throws ProxoolException if the configuration fails. * @throws SQLException if ProxoolFacade operation fails. */ public void testWithNamspaces() throws ProxoolException, SQLException { final String xmlFile = "src/java-test/org/logicalcobwebs/proxool/configuration/test-ns.xml"; JAXPConfigurator.configure(xmlFile, false); try { assertNotNull("2nd (deeply nested) pool was not configured.", ProxoolFacade.getConnectionPoolDefinition("xml-test-ns-2")); } catch (ProxoolException e) { fail("2nd (deeply nested) pool was not configured."); } TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("xml-test-ns")); TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("xml-test-ns-2")); } /** * Test that the confguration succeds and that all expected properties * has been received by Proxool, and that validiation succceds. This test is done with a * xml without namespaces. * @throws ProxoolException if the configuration fails. * @throws SQLException if ProxoolFacade operation fails. * @throws FileNotFoundException if the xml file is not found. */ public void testValidiation() throws ProxoolException, SQLException, FileNotFoundException { final String xmlFile = "src/java-test/org/logicalcobwebs/proxool/configuration/test-valid.xml"; final InputSource inputSource = new InputSource(new FileInputStream(xmlFile)); inputSource.setSystemId(getWorkingDirectoryUrl()); JAXPConfigurator.configure(inputSource, true); try { assertNotNull("2nd (deeply nested) pool was not configured.", ProxoolFacade.getConnectionPoolDefinition("xml-test-validating-2")); } catch (ProxoolException e) { fail("2nd (deeply nested) pool was not configured."); } TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("xml-test-validating")); TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("xml-test-validating-2")); } /** * Test that we can retrieve a conncetion using the alias after registration * @throws ProxoolException if the configuration fails. * @throws SQLException if ProxoolFacade operation fails. * @throws FileNotFoundException if the xml file is not found. */ public void testWithAlias() throws ProxoolException, SQLException, FileNotFoundException { final String xmlFile = "src/java-test/org/logicalcobwebs/proxool/configuration/test-valid.xml"; final InputSource inputSource = new InputSource(new FileInputStream(xmlFile)); inputSource.setSystemId(getWorkingDirectoryUrl()); JAXPConfigurator.configure(inputSource, true); final String alias = "xml-test-validating"; DriverManager.getConnection(ProxoolConstants.PROXOOL + "." + alias).close(); } /** * Test that the confguration fails when validiation is turned on and the given xml is not valid. * @throws SQLException if ProxoolFacade operation fails. * @throws FileNotFoundException if the xml file is not found. */ public void testValidiationFailure() throws SQLException, FileNotFoundException, ProxoolException { final String xmlFile = "src/java-test/org/logicalcobwebs/proxool/configuration/test-not-valid.xml"; final InputSource inputSource = new InputSource(new FileInputStream(xmlFile)); inputSource.setSystemId(getWorkingDirectoryUrl()); boolean failure = false; try { JAXPConfigurator.configure(inputSource, true); } catch (ProxoolException e) { failure = true; } assertTrue("Configuration did not fail on unvalid xml document.", failure); } private static String getWorkingDirectoryUrl() { String userDir = System.getProperty("user.dir"); String toReplace = "\\"; String replaceWith = "/"; int pos = 0; if (!toReplace.equals(replaceWith)) { while (true) { pos = userDir.indexOf(toReplace, pos); if (pos == -1) { break; } userDir = userDir.substring(0, pos) + replaceWith + userDir.substring(pos + toReplace.length()); pos += replaceWith.length(); } } if (!userDir.startsWith("/")) { userDir = "/" + userDir; } if (!userDir.endsWith("/")) { userDir = userDir + "/"; } return "file://" + userDir; } } /* Revision history: $Log: JAXPConfiguratorTest.java,v $ Revision 1.16 2003/08/30 14:54:23 billhorsman Checkstyle Revision 1.15 2003/04/29 11:51:49 billhorsman added new "with-alias" test Revision 1.14 2003/03/04 10:58:45 billhorsman checkstyle Revision 1.13 2003/03/04 10:24:41 billhorsman removed try blocks around each test Revision 1.12 2003/03/03 17:36:33 billhorsman leave shutdown to AbstractProxoolTest Revision 1.11 2003/03/03 17:09:18 billhorsman all tests now extend AbstractProxoolTest Revision 1.10 2003/03/03 11:12:06 billhorsman fixed licence Revision 1.9 2003/03/01 15:27:25 billhorsman checkstyle Revision 1.8 2003/02/27 18:01:49 billhorsman completely rethought the test structure. it's now more obvious. no new tests yet though. Revision 1.7 2003/02/19 15:14:27 billhorsman fixed copyright (copy and paste error, not copyright change) Revision 1.6 2003/01/18 15:13:14 billhorsman Signature changes (new ProxoolException thrown) on the ProxoolFacade API. Revision 1.5 2002/12/18 03:13:00 chr32 Added tests for xml validation. Revision 1.4 2002/12/16 17:06:41 billhorsman new test structure Revision 1.3 2002/12/16 02:35:40 chr32 Updated to new driver-properties xml format. Revision 1.2 2002/12/15 19:41:26 chr32 Style fixes. Revision 1.1 2002/12/15 19:10:49 chr32 Init rev. */ ././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/LogKitTargetAdapter.java libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/LogKitTargetAdapte0000644 0001750 0001750 00000010711 10730503130 033724 0 ustar twerner twerner /* * This software is released under a licence similar to the Apache Software Licence. * See org.logicalcobwebs.proxool.package.html for details. * The latest version is available at http://proxool.sourceforge.net */ package org.logicalcobwebs.proxool.configuration; import org.apache.avalon.framework.CascadingThrowable; import org.apache.log.LogEvent; import org.apache.log.Priority; import org.apache.log.output.AbstractOutputTarget; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * An Avalon LogKit target that delegates to a Jakarta Commonsorg.apache.commons.logging.Log.
* Can be used to make Avalons internal logging go the same output as
* the Proxool internal logging.
* @version $Revision: 1.6 $, $Date: 2006/01/18 14:40:06 $
* @author Christian Nedregaard (christian_nedregaard@email.com)
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.6
*/
public class LogKitTargetAdapter extends AbstractOutputTarget {
private boolean isOpen = true;
/**
* @see org.apache.log.output.AbstractOutputTarget#doProcessEvent(org.apache.log.LogEvent)
*/
protected void doProcessEvent(LogEvent event) {
// we do a workaround for the fact that Avalon CascadingThrowables
// does not print the stacktrace of any nested exceptions.
// Also we 'upgrade' DEBUG LogEvents containing Throwables
// to WARN since Avalon seems to give some important exceptions
// DEBUG priority.
Throwable originalThrowable = event.getThrowable();
Throwable nestedThrowable = null;
if (originalThrowable != null && originalThrowable instanceof CascadingThrowable) {
nestedThrowable = ((CascadingThrowable) originalThrowable).getCause();
}
int priority = event.getPriority().getValue();
if (originalThrowable != null && event.getPriority().isLower(Priority.WARN)) {
priority = Priority.WARN.getValue();
}
Log logger = LogFactory.getLog(event.getCategory());
if (Priority.DEBUG.getValue() == priority) {
if (logger.isDebugEnabled()) {
logger.debug(event.getMessage(), originalThrowable);
}
if (nestedThrowable != null) {
logger.debug("... caused by:", nestedThrowable);
}
} else if (Priority.INFO.getValue() == priority) {
if (logger.isInfoEnabled()) {
logger.info(event.getMessage(), originalThrowable);
}
if (nestedThrowable != null) {
logger.info("... caused by:", nestedThrowable);
}
} else if (Priority.WARN.getValue() == priority) {
logger.warn(event.getMessage(), originalThrowable);
if (nestedThrowable != null) {
logger.warn("... caused by:", nestedThrowable);
}
} else if (Priority.ERROR.getValue() == priority) {
logger.error(event.getMessage(), originalThrowable);
if (nestedThrowable != null) {
logger.error("... caused by:", nestedThrowable);
}
} else if (Priority.FATAL_ERROR.getValue() == priority) {
logger.fatal(event.getMessage(), originalThrowable);
if (nestedThrowable != null) {
logger.fatal("... caused by:", nestedThrowable);
}
} else {
logger.warn("Got log event of unknown priority: " + priority
+ ". Message: " + event.getMessage(), originalThrowable);
}
}
/**
* @see org.apache.log.output.AbstractOutputTarget#isOpen()
*/
protected boolean isOpen() {
return this.isOpen;
}
/**
* @see org.apache.log.output.AbstractOutputTarget#open()
*/
protected void open() {
this.isOpen = true;
}
/**
* @see org.apache.log.output.AbstractOutputTarget#close()
*/
public void close() {
this.isOpen = false;
}
}
/*
Revision history:
$Log: LogKitTargetAdapter.java,v $
Revision 1.6 2006/01/18 14:40:06 billhorsman
Unbundled Jakarta's Commons Logging.
Revision 1.5 2003/03/04 10:24:41 billhorsman
removed try blocks around each test
Revision 1.4 2003/03/03 11:12:06 billhorsman
fixed licence
Revision 1.3 2003/03/01 15:27:25 billhorsman
checkstyle
Revision 1.2 2003/02/06 17:41:03 billhorsman
now uses imported logging
Revision 1.1 2002/12/23 02:39:43 chr32
Needed by the AvalonConfigurator tests.
*/ ././@LongLink 0000000 0000000 0000000 00000000160 00000000000 011562 L ustar root root libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/PropertyConfiguratorTest.java libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/PropertyConfigurat0000644 0001750 0001750 00000004744 10730503127 034132 0 ustar twerner twerner /*
* This software is released under a licence similar to the Apache Software Licence.
* See org.logicalcobwebs.proxool.package.html for details.
* The latest version is available at http://proxool.sourceforge.net
*/
package org.logicalcobwebs.proxool.configuration;
import org.logicalcobwebs.proxool.AbstractProxoolTest;
import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.ProxoolFacade;
import org.logicalcobwebs.proxool.TestHelper;
import java.sql.SQLException;
/**
* Tests that the PropertyConfigurator works.
*
* @version $Revision: 1.8 $, $Date: 2003/03/04 10:58:45 $
* @author Christian Nedregaard (christian_nedregaard@email.com)
* @author $Author: billhorsman $ (current maintainer)
* @since Proxool 0.6
*/
public class PropertyConfiguratorTest extends AbstractProxoolTest {
/**
* @see junit.framework.TestCase#TestCase
*/
public PropertyConfiguratorTest(String name) {
super(name);
}
/**
* Test that the configuration succeds and that all expected properties
* has been received by Proxool.
* @throws ProxoolException if the configuration fails.
* @throws SQLException if ProxoolFacade operation fails.
*/
public void testPropertyConfigurator() throws ProxoolException, SQLException {
PropertyConfigurator.configure("src/java-test/org/logicalcobwebs/proxool/configuration/test.properties");
TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("property-test"));
TestHelper.equalsCompleteAlternativeProperties(ProxoolFacade.getConnectionPoolDefinition("property-test-2"));
ProxoolFacade.removeConnectionPool("property-test");
ProxoolFacade.removeConnectionPool("property-test-2");
}
}
/*
Revision history:
$Log: PropertyConfiguratorTest.java,v $
Revision 1.8 2003/03/04 10:58:45 billhorsman
checkstyle
Revision 1.7 2003/03/04 10:24:41 billhorsman
removed try blocks around each test
Revision 1.6 2003/03/03 17:09:18 billhorsman
all tests now extend AbstractProxoolTest
Revision 1.5 2003/03/03 11:12:07 billhorsman
fixed licence
Revision 1.4 2003/03/01 15:27:25 billhorsman
checkstyle
Revision 1.3 2003/02/27 18:01:49 billhorsman
completely rethought the test structure. it's now
more obvious. no new tests yet though.
Revision 1.2 2003/02/19 15:14:27 billhorsman
fixed copyright (copy and paste error,
not copyright change)
Revision 1.1 2002/12/26 11:34:15 billhorsman
Init rev.
*/
libproxool-java-0.9.1.orig/src/java-test/org/logicalcobwebs/proxool/configuration/component-ns.conf 0000644 0001750 0001750 00000005150 10730503130 033612 0 ustar twerner twerner false when trying to removed an unregistered listener.
*/
public void testRemove() {
TestListenerIF[] testListeners = new TestListenerIF[]{
new TestListener(), new TestListener(), new TestListener(), new TestListener(),
new TestListener(), new TestListener(), new TestListener(), new TestListener(),
new TestListener(), new TestListener()
};
CompositeTestListener compositeTestListener = new CompositeTestListener();
for (int i = 0; i < 10; ++i) {
compositeTestListener.addListener(testListeners[i]);
}
for (int i = 0; i < 10; ++i) {
assertTrue("Removal of a listener failed.", compositeTestListener.removeListener(testListeners[i]));
}
assertTrue("Removal of unregistered listener returned true",
!compositeTestListener.removeListener(new TestListener()));
compositeTestListener.onEvent();
assertTrue("Listeners was notified even if all listeners had been removed.",
compositeTestListener.getNumberOfNotifications() == 0);
}
}
interface TestListenerIF {
void onEvent();
}
class CompositeTestListener extends AbstractListenerContainer implements TestListenerIF {
private int numberOfNotifications;
public void onEvent() {
Object[] listeners = getListeners();
for(int i=0; i