You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ode.apache.org by bo...@apache.org on 2008/11/15 15:48:01 UTC

svn commit: r717863 - /ode/branches/APACHE_ODE_1.X/scheduler-simple/src/main/java/org/apache/ode/scheduler/simple/SimpleScheduler.java

Author: boisvert
Date: Sat Nov 15 06:48:01 2008
New Revision: 717863

URL: http://svn.apache.org/viewvc?rev=717863&view=rev
Log:
Make scheduler properties configurable

Modified:
    ode/branches/APACHE_ODE_1.X/scheduler-simple/src/main/java/org/apache/ode/scheduler/simple/SimpleScheduler.java

Modified: ode/branches/APACHE_ODE_1.X/scheduler-simple/src/main/java/org/apache/ode/scheduler/simple/SimpleScheduler.java
URL: http://svn.apache.org/viewvc/ode/branches/APACHE_ODE_1.X/scheduler-simple/src/main/java/org/apache/ode/scheduler/simple/SimpleScheduler.java?rev=717863&r1=717862&r2=717863&view=diff
==============================================================================
--- ode/branches/APACHE_ODE_1.X/scheduler-simple/src/main/java/org/apache/ode/scheduler/simple/SimpleScheduler.java (original)
+++ ode/branches/APACHE_ODE_1.X/scheduler-simple/src/main/java/org/apache/ode/scheduler/simple/SimpleScheduler.java Sat Nov 15 06:48:01 2008
@@ -43,7 +43,7 @@
  * A reliable and relatively simple scheduler that uses a database to persist information about 
  * scheduled tasks.
  * 
- * The challange is to achieve high performance in a small memory footprint without loss of reliability
+ * The challenge is to achieve high performance in a small memory footprint without loss of reliability
  * while supporting distributed/clustered configurations.
  * 
  * The design is based around three time horizons: "immediate", "near future", and "everything else". 
@@ -119,10 +119,26 @@
     public SimpleScheduler(String nodeId, DatabaseDelegate del, Properties conf) {
         _nodeId = nodeId;
         _db = del;
-        _todoLimit = Integer.parseInt(conf.getProperty("ode.scheduler.queueLength", "10000"));
+        _todoLimit = getIntProperty(conf, "ode.scheduler.queueLength", _todoLimit);
+        _immediateInterval = getLongProperty(conf, "ode.scheduler.immediateInterval", _immediateInterval);
+        _nearFutureInterval = getLongProperty(conf, "ode.scheduler.nearFutureInterval", _nearFutureInterval);
+        _staleInterval = getLongProperty(conf, "ode.scheduler.staleInterval", _staleInterval);
+        _tps = getIntProperty(conf, "ode.scheduler.transactionsPerSecond", _tps);
         _todo = new SchedulerThread(this);
     }
 
+    private int getIntProperty(Properties props, String propName, int defaultValue) {
+        String s = props.getProperty(propName);
+        if (s != null) return Integer.parseInt(s);
+        else return defaultValue;
+    }
+
+    private long getLongProperty(Properties props, String propName, long defaultValue) {
+        String s = props.getProperty(propName);
+        if (s != null) return Long.parseLong(s);
+        else return defaultValue;
+    }
+        
     public void setNodeId(String nodeId) {
         _nodeId = nodeId;
     }
@@ -139,7 +155,7 @@
         _nearFutureInterval = nearFutureInterval;
     }
 
-    public void setTransactionPerSecond(int tps) {
+    public void setTransactionsPerSecond(int tps) {
         _tps = tps;
     }
 
@@ -318,15 +334,19 @@
         _todo.enqueue(new LoadImmediateTask(now));
 
         // schedule check for stale nodes, make it random so that the nodes don't overlap.
-        _todo.enqueue(new CheckStaleNodes(now + (long) (_random.nextDouble() * _staleInterval + (_staleInterval/2))));
+        _todo.enqueue(new CheckStaleNodes(now + randomMean(_staleInterval)));
 
         // do the upgrade sometime (random) in the immediate interval.
-        _todo.enqueue(new UpgradeJobsTask(now + (long) (_random.nextDouble() * _immediateInterval + (_immediateInterval/2))));
+        _todo.enqueue(new UpgradeJobsTask(now + randomMean(_immediateInterval)));
 
         _todo.start();
         _running = true;
     }
-
+    
+    private long randomMean(long mean) {
+        return (long) _random.nextDouble() * mean + (mean/2);
+    }
+        
     public synchronized void stop() {
         if (!_running)
             return;