Merge pull request #6 from little-pan/v0.3.29-fix-kill

fix - can't kill process issue

Author: forchid

bin/build.sh

@@ -1,4 +1,24 @@
 #!/bin/sh
+
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Build Script for the SQLite Server
+# -----------------------------------------------------------------------------
+
 if [ -z "$JAVA_HOME" ] ; then
   if [[ "$OSTYPE" == "darwin"* ]]; then
     if [ -d "/System/Library/Frameworks/JavaVM.framework/Home" ] ; then

bin/startup.bat

@@ -20,7 +20,7 @@ rem Boot script for the SQLite Server
 rem ---------------------------------------------------------------------------
 setlocal
 
-set JAVA_OPTS=-Xmx128m
+set JAVA_OPTS=-Xmx256m
 
 rem Guess SQLITED_HOME if not defined
 set "CURRENT_DIR=%cd%"

bin/startup.sh

@@ -19,7 +19,7 @@
 # Boot Script for the SQLite Server
 # -----------------------------------------------------------------------------
 
-export JAVA_OPTS=-Xmx128m
+export JAVA_OPTS=-Xmx256m
 
 BIN_DIR=`dirname "$PRG"`
 export SQLITED_HOME=`dirname "$BIN_DIR"`

src/main/java/org/sqlite/server/SQLiteProcessor.java

@@ -903,9 +903,50 @@ public boolean isCurrentUser(User other) {
                 && user.getHost().equals(other.getHost()));
     }
 
+    protected boolean shutdownInput() {
+        final SocketChannel ch = this.channel;
+        if (ch == null) {
+            return false;
+        }
+        
+        if (ch.isConnected() && ch.isOpen()) {
+            try {
+                trace(log, "{}: shutdown input", this);
+                ch.shutdownInput();
+                return true;
+            } catch (IOException e) {
+                // ignore
+            }
+        }
+        return false;
+    }
+    
+    protected boolean shutdownOutput() {
+        final SocketChannel ch = this.channel;
+        if (ch == null) {
+            return false;
+        }
+        
+        if (ch.isConnected() && ch.isOpen()) {
+            try {
+                trace(log, "{}: shutdown output", this);
+                ch.shutdownOutput();
+                return true;
+            } catch (IOException e) {
+                // ignore
+            }
+        }
+        return false;
+    }
+    
     public void stop() {
+        if (isStopped()) {
+            return;
+        }
         this.stopped = true;
         this.state.stop();
+        shutdownInput();
+        this.worker.wakeup();
     }
 
     public boolean isStopped() {
@@ -937,6 +978,7 @@ public void close() {
         this.savepointStack = null;
 
         // release connections
+        shutdownOutput();
         IoUtils.close(this.channel);
         this.channel = null;
         IoUtils.close(this.connection);

src/main/java/org/sqlite/server/SQLiteWorker.java

@@ -163,10 +163,12 @@ public void close(SQLiteProcessor processor) {
     @Override
     public void run() {
         try {
-            for (; !isStopped() || this.processors.size() > 0;) {
+            SlotAllocator<SQLiteProcessor> processors = this.processors;
+            for (; !isStopped() || processors.size() > 0;) {
                 long timeout = minSelectTimeout();
                 int n;
                 if (timeout < 0L) {
+                    processIdle();
                     n = this.selector.select();
                 } else if (timeout == 0L) {
                     n = this.selector.selectNow();
@@ -202,6 +204,7 @@ protected void processQueues(long runNanos) throws IllegalStateException {
         Selector selector = this.selector;
         long deadNano = System.nanoTime() + runNanos;
         // Q1: procQueue
+        SlotAllocator<SQLiteProcessor> processors = this.processors;
         for (;;) {
             if (runNanos > 0L && System.nanoTime() > deadNano) {
                 return;
@@ -216,7 +219,7 @@ protected void processQueues(long runNanos) throws IllegalStateException {
                 p.setSelector(selector);
                 p.setWorker(this);
                 p.setName(this.name + "-" + p.getName());
-                if (this.processors.size() >= this.maxConns) {
+                if (processors.size() >= this.maxConns) {
                     p.tooManyConns();
                     p.stop();
                     p.enableWrite();
@@ -230,7 +233,7 @@ protected void processQueues(long runNanos) throws IllegalStateException {
                     }
                     this.procsLock.lock();
                     try {
-                        final int slot = this.processors.allocate(p);
+                        final int slot = processors.allocate(p);
                         if (slot == -1) {
                             throw new IllegalStateException("Processor allocator full");
                         }
@@ -284,7 +287,23 @@ protected void processQueues(long runNanos) throws IllegalStateException {
         }
     }
 
+    protected void processIdle() {
+        SlotAllocator<SQLiteProcessor> processors = this.processors;
+        this.procsLock.lock();
+        try {
+            for (int i = 0, n = processors.maxSlot(); i < n; ++i) {
+                SQLiteProcessor p = processors.get(i);
+                if (p != null && p.isStopped()) {
+                    p.write();
+                }
+            }
+        } finally {
+            this.procsLock.unlock();
+        }
+    }
+    
     protected void processIO() {
+        final Thread currThead = Thread.currentThread();
         Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();
         for (; keys.hasNext(); keys.remove()) {
             SelectionKey key = keys.next();
@@ -297,18 +316,18 @@ protected void processIO() {
             if (key.isWritable()) {
                 try {
                     p = (SQLiteProcessor)key.attachment();
-                    Thread.currentThread().setName(p.getName());
+                    currThead.setName(p.getName());
                     p.write();
                 } finally {
-                    Thread.currentThread().setName(this.name);
+                    currThead.setName(this.name);
                 }
             } else if (key.isReadable()) {
                 try {
                     p = (SQLiteProcessor)key.attachment();
-                    Thread.currentThread().setName(p.getName());
+                    currThead.setName(p.getName());
                     p.read();
                 } finally {
-                    Thread.currentThread().setName(this.name);
+                    currThead.setName(this.name);
                 }
             } else {
                 key.cancel();
@@ -411,10 +430,11 @@ protected long minSelectTimeout() {
     }
 
     SQLiteProcessor getProcessor(int pid) {
+        SlotAllocator<SQLiteProcessor> processors = this.processors;
         this.procsLock.lock();
         try {
-            for (int i = 0, n = this.processors.maxSlot(); i < n; ++i) {
-                SQLiteProcessor p = this.processors.get(i);
+            for (int i = 0, n = processors.maxSlot(); i < n; ++i) {
+                SQLiteProcessor p = processors.get(i);
                 if (p != null && p.getId() == pid) {
                     return p;
                 }
@@ -426,12 +446,13 @@ SQLiteProcessor getProcessor(int pid) {
     }
 
     public List<SQLiteProcessorState> getProcessorStates(final SQLiteProcessor processor) {
+        SlotAllocator<SQLiteProcessor> processors = this.processors;
         this.procsLock.lock();
         try {
             List<SQLiteProcessorState> states = new ArrayList<>();
             final User user = processor.getUser();
-            for (int i = 0, n = this.processors.maxSlot(); i < n; ++i) {
-                final SQLiteProcessor p = this.processors.get(i);
+            for (int i = 0, n = processors.maxSlot(); i < n; ++i) {
+                final SQLiteProcessor p = processors.get(i);
                 if (p == null) {
                     continue;
                 }

src/test/java/org/sqlite/TestDbBase.java

@@ -36,7 +36,12 @@
  *
  */
 public abstract class TestDbBase extends TestBase {
-    
+    static {
+        if (System.getProperty("SQLITED_HOME") == null) {
+            String defaultDir = System.getProperty("user.dir");
+            System.setProperty("SQLITED_HOME", defaultDir);
+        }
+    }
     protected static final String dataDir = getDataDir();
 
     protected static String user = "root";
@@ -65,11 +70,11 @@ public abstract class TestDbBase extends TestBase {
     protected static final String [][] initArgsList = new String[][] {
         {"-D", dataDir, "-p", password, "--journal-mode", "wal"},
         {"-D", dataDir, "-p", password, "--journal-mode", "delete", 
-            "-S", "off"
+            "-S", "normal"
         },
         {"-D", dataDir, "-p", password, "--journal-mode", "wal"},
         {"-D", dataDir, "-p", password, "--journal-mode", "delete", 
-            "-S", "off"
+            "-S", "normal"
         },
     };
 
@@ -95,6 +100,10 @@ public abstract class TestDbBase extends TestBase {
     protected DbTestEnv currentEnv;
     protected int envIndex, envMax;
 
+    protected TestDbBase() {
+        
+    }
+    
     protected void init() {
         this.envIndex = 0;
         this.envMax   = initArgsList.length;