Merge lp:~nchohan/appscale/SSLCassyMysql into lp:appscale

[Navraj Chohan]

Tested with tasks on all databases. All of them work except for Voldemort. Voldemort works for guestbook.

[lp:~nchohan/appscale/SSLCassyMysql]

480. By root <root@appscale-image> on 2010-06-29

merging with SSLCassyMySQL

481. By root <root@appscale-image0> on 2010-06-29

dropping database

482. By root <root@appscale-image0> on 2010-06-29

merged in changes, fixed conflicts

[Chris Bunch (cgb-cs)]

All databases other than MySQL appear to work fine (haven't tried apps other than guestbook yet). MySQL has failed twice. Sample output from one run:

Traceback (most recent call last):
  File "/root/appscale/AppDB/mysql/prime_mysql.py", line 64, in <module>
    drop_database()
  File "/root/appscale/AppDB/mysql/prime_mysql.py", line 32, in drop_database
    cursor.execute("DROP DATABASE IF EXISTS appscale;")
  File "/var/lib/python-support/python2.6/MySQLdb/cursors.py", line 166, in execute
    self.errorhandler(self, exc, value)
  File "/var/lib/python-support/python2.6/MySQLdb/connections.py", line 35, in defaulterrorhandler
    raise errorclass, errorvalue
_mysql_exceptions.OperationalError: (1051, "Unknown table 'xUSERS__'")

...

gzip: stdin: unexpected end of file
tar: Child returned status 1
tar: Error exit delayed from previous errors
[Tue Jun 29 17:39:47 +0000 2010] saw a cron request with args [128.111.55.237][][guestbook]
cron: lang was neither python nor java but was []
cron: lang was neither python nor java but was []
/root/appscale/AppDB/mysql/prime_mysql.py:55: Warning: Table 'xAPPS__' already exists

Will try running MySQL again.

[Chris Bunch (cgb-cs)]

MySQL works fine for me on a single node, but fails on the four node case. Tried both -n 1 and -n 2, but both fail.

[Chris Bunch (cgb-cs)]

Accepted. MySQL on >1 nodes needs to be fixed, and would like to not have the load balancer use SSL for all communication (this way if all the user cares about is app redirection then they don't see the SSL cert problem).

review: Approve

=== modified file 'AppController/djinn.rb'
--- AppController/djinn.rb	2010-06-25 22:28:38 +0000
+++ AppController/djinn.rb	2010-06-29 01:49:23 +0000
@@ -101,6 +101,7 @@
     my_data = my_node
     if has_soap_server?(my_data)
       stop_soap_server
+      stop_pbserver
     end
 
     jobs_to_run = my_data.jobs
@@ -507,7 +508,8 @@
   def self.get_nearest_db_ip(is_mysql=false)
     db_ips = self.get_db_slave_ips
     # Unless this is mysql we include the master ip
-    db_ips << self.get_db_master_ip if !is_mysql
+    # Update, now mysql also has an API node
+    db_ips << self.get_db_master_ip
     db_ips.compact!
     
     local_ip = HelperFunctions.local_ip
@@ -810,21 +812,23 @@
       end
       if retval != 0
         Djinn.log_debug("Fail to create initial table. Could not startup AppScale.")
+        exit(1)
         # TODO: terminate djinn
       end
     end
 
     # start soap server and pb server
     if has_soap_server?(my_data)
+      @state = "Starting up SOAP Server and PBServer"
+      start_pbserver
       start_soap_server
+      HelperFunctions.sleep_until_port_is_open(HelperFunctions.local_ip, UA_SERVER_PORT)
     end
 
-    # no longer need to start appengine here
+    # appengine is started elsewhere
   end
 
   def start_soap_server
-    @state = "Starting up SOAP Server and Appscale Server(PB server)"
-
     db_master_ip = nil
     @nodes.each { |location|
       db_master_ip = location.private_ip if location.is_db_master?
@@ -846,28 +850,31 @@
             "-s #{HelperFunctions.get_secret}"]
     Djinn.log_debug(cmd.join(" "))
     Kernel.system cmd.join(" ")
+  end 
+
+  def start_pbserver
+    db_master_ip = nil
+    my_ip = my_node.public_ip
+    @nodes.each { |location|
+      db_master_ip = location.private_ip if location.is_db_master?
+    }
+    abort("db master ip was nil") if db_master_ip.nil?
+    table = @creds['table']
     zoo_connection = get_zk_connection_string(@nodes)
-    cmd = [ "MASTER_IP=#{db_master_ip} LOCAL_DB_IP='#{db_local_ip}'",
-            "start-stop-daemon --start",
-            "--exec /usr/bin/python2.6",
-            "--name appscale_server",
-            "--make-pidfile",
-            "--pidfile /var/appscale/appscale-appscaleserver.pid",
-            "--background",
-            "--",
-            "#{APPSCALE_HOME}/AppDB/appscale_server.py",
-            "--type #{table}",
-            "-z \"#{zoo_connection}\"",
-            "-s #{HelperFunctions.get_secret}",
-            "-a #{get_uaserver_ip} --key"]
-    Djinn.log_debug(cmd.join(" "))
-    Kernel.system cmd.join(" ")
-    HelperFunctions.sleep_until_port_is_open(HelperFunctions.local_ip, UA_SERVER_PORT)
+    PbServer.start(db_master_ip, @userappserver_private_ip, my_ip, table, zoo_connection)
+    HAProxy.create_pbserver_config(my_ip, PbServer.proxy_port)
+    Nginx.create_pbserver_config(my_ip, PbServer.proxy_port)
+    Nginx.restart 
+    # TODO check the return value
+    PbServer.is_running
   end
 
   def stop_soap_server
     Kernel.system "start-stop-daemon --stop --pidfile /var/appscale/appscale-soapserver.pid"
-    Kernel.system "start-stop-daemon --stop --pidfile /var/appscale/appscale-appscaleserver.pid"
+  end 
+
+  def stop_pbserver
+    PbServer.stop 
   end
 
   def is_cloud?

=== modified file 'AppController/haproxy.rb'
--- AppController/haproxy.rb	2010-06-25 22:28:38 +0000
+++ AppController/haproxy.rb	2010-06-29 01:49:23 +0000
@@ -61,6 +61,11 @@
     self.create_app_config(my_ip, listen_port, Monitoring.server_ports, Monitoring.name)
   end
 
+  # Create the config file for PBServer applications
+  def self.create_pbserver_config(my_ip, listen_port)
+    self.create_app_config(my_ip, listen_port, PbServer.server_ports, PbServer.name)
+  end
+
   # A generic function for creating haproxy config files used by appscale services
   def self.create_app_config(my_ip, listen_port, server_ports, name)
     servers = []

=== modified file 'AppController/helperfunctions.rb'
--- AppController/helperfunctions.rb	2010-06-01 19:38:10 +0000
+++ AppController/helperfunctions.rb	2010-06-29 01:49:23 +0000
@@ -23,7 +23,8 @@
 TIME_IN_SECONDS = { "d" => 86400, "h" => 3600, "m" => 60, "s" => 1 }
 
 APP_START_PORT = 20000
-
+DEFAULT_PBSERVER_PORT = 8443
+DEFAULT_PBSERVER_NOENCRYPT_PORT = 8888
 module HelperFunctions
   def self.write_file(location, contents)
     File.open(location, "w+") { |file| file.write(contents) }
@@ -204,15 +205,18 @@
       Djinn.log_debug("saw a python app coming through")
       cmd = ["MY_IP_ADDRESS=#{public_ip}",
              "MY_PORT=#{port}",
-             "NGINX_ADDRESS=#{public_ip}",
-             "NGINX_PORT=#{nginx_port}",
+             #"NGINX_ADDRESS=#{public_ip}",
+             #"NGINX_PORT=#{nginx_port}",
              "python2.5",
              "#{APPSCALE_HOME}/AppServer/dev_appserver.py",
              "-p #{port}",
              "--cookie_secret #{secret}",
              "--login_server #{public_ip}",
              "--admin_console_server ''",
-             "--datastore_path #{db_location}",
+             "--nginx_port #{nginx_port}",
+             "--nginx_host #{public_ip}",
+             "--enable_sendmail",
+             "--datastore_path #{db_location}:#{DEFAULT_PBSERVER_NOENCRYPT_PORT}",
              "--history_path /var/apps/#{app_name}/data/app.datastore.history",
 # this is not working.
 #             "--address=#{public_ip}",

=== modified file 'AppController/load_balancer.rb'
--- AppController/load_balancer.rb	2010-04-21 20:53:02 +0000
+++ AppController/load_balancer.rb	2010-06-29 01:49:23 +0000
@@ -7,6 +7,7 @@
   PROXY_PORT = 8060
   # The port which requests to this app will be served from
   LISTEN_PORT = 80
+  LISTEN_SSL_PORT = 443
 
   def self.start
     `service appscale-loadbalancer start`
@@ -33,6 +34,10 @@
     LISTEN_PORT
   end
 
+  def self.listen_ssl_port
+    LISTEN_SSL_PORT
+  end
+
   def self.server_ports
     SERVER_PORTS
   end

=== modified file 'AppController/nginx.rb'
--- AppController/nginx.rb	2010-06-25 22:28:38 +0000
+++ AppController/nginx.rb	2010-06-29 01:49:23 +0000
@@ -5,7 +5,7 @@
 require 'fileutils'
 require 'load_balancer'
 require 'monitoring'
-
+require 'pbserver'
 
 # A class to wrap all the interactions with the nginx web server
 class Nginx
@@ -72,9 +72,6 @@
 
     #{static_locations}
 
-    location /_ah/admin {
-      # 404 - lock out admin routes
-    }
 
     location / {
       proxy_set_header  X-Real-IP  $remote_addr;
@@ -117,7 +114,7 @@
 
   # Create the configuration file for the AppLoadBalancer Rails application
   def self.create_app_load_balancer_config(my_ip, proxy_port)
-    self.create_app_config(my_ip, proxy_port, LoadBalancer.listen_port, LoadBalancer.name, LoadBalancer.public_directory)
+    self.create_app_config(my_ip, proxy_port, LoadBalancer.listen_port, LoadBalancer.name, LoadBalancer.public_directory, LoadBalancer.listen_ssl_port)
   end
 
   # Create the configuration file for the AppMonitoring Rails application
@@ -125,6 +122,68 @@
     self.create_app_config(my_ip, proxy_port, Monitoring.listen_port, Monitoring.name, Monitoring.public_directory)
   end
 
+  # Create the configuration file for the pbserver
+  def self.create_pbserver_config(my_ip, proxy_port)
+    config = <<CONFIG
+upstream #{PbServer.name} {
+    server #{my_ip}:#{proxy_port};
+}
+    
+server {
+    listen #{PbServer.listen_port};
+    server_name #{my_ip};
+    root /root/appscale/AppDB/;
+    access_log  /var/log/nginx/pbserver.access.log upstream;
+    error_log  /var/log/nginx/pbserver.error.log;
+    rewrite_log off;
+    error_page 404 = /404.html;
+
+
+
+    location / {
+      proxy_set_header  X-Real-IP  $remote_addr;
+      proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header Host $http_host;
+      proxy_redirect off;
+      proxy_pass http://#{PbServer.name};
+    }
+
+}
+
+server {
+    listen #{PbServer.listen_ssl_port};
+    ssl on;
+    ssl_certificate /etc/nginx/mycert.pem;
+    ssl_certificate_key /etc/nginx/mykey.pem;
+    root /root/appscale/AppDB/public;
+    access_log  /var/log/nginx/pbencrypt.access.log upstream;
+    error_log  /var/log/nginx/pbencrypt.error.log;
+    rewrite_log off;
+    error_page 502 /502.html;
+
+    location / {
+      proxy_set_header  X-Real-IP  $remote_addr;
+      proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header Host $http_host;
+      proxy_redirect off;
+
+      client_body_timeout 60;
+      proxy_read_timeout 60;
+      #Increase file size so larger applications can be uploaded
+      client_max_body_size 30M;
+      # go to proxy
+      proxy_pass http://#{PbServer.name};
+    }
+}
+CONFIG
+    config_path = File.join(SITES_ENABLED_PATH, "#{PbServer.name}.#{CONFIG_EXTENSION}")
+    File.open(config_path, "w+") { |dest_file| dest_file.write(config) }
+
+    HAProxy.regenerate_config
+
+  end
+
+
   # A generic function for creating nginx config files used by appscale services
   def self.create_app_config(my_ip, proxy_port, listen_port, name, public_dir, ssl_port=nil)
 
@@ -132,9 +191,30 @@
 upstream #{name} {
    server #{my_ip}:#{proxy_port};
 }
-
-server {
-    listen #{listen_port};
+CONFIG
+
+    if ssl_port
+      # redirect all request to ssl port.
+      config += <<CONFIG
+server {
+    listen #{listen_port};
+    rewrite ^(.*) https://#{my_ip}:#{ssl_port}$1 permanent;
+}
+
+server {
+    listen #{ssl_port};
+    ssl on;
+    ssl_certificate #{NGINX_PATH}/mycert.pem;
+    ssl_certificate_key #{NGINX_PATH}/mykey.pem;
+CONFIG
+    else
+      config += <<CONFIG
+server {
+    listen #{listen_port};
+CONFIG
+    end
+
+    config += <<CONFIG
     root #{public_dir};
     access_log  /var/log/nginx/load-balancer.access.log upstream;
     error_log  /var/log/nginx/load-balancer.error.log;
@@ -165,7 +245,6 @@
       root #{APPSCALE_HOME}/AppLoadBalancer/public;
     }
 }
-
 CONFIG
 
     config_path = File.join(SITES_ENABLED_PATH, "#{name}.#{CONFIG_EXTENSION}")
@@ -209,9 +288,6 @@
 
     gzip  on;
 
-    ssl_certificate #{NGINX_PATH}/cert.pem;
-    ssl_certificate_key #{NGINX_PATH}/cert.key;
-
     include #{NGINX_PATH}/sites-enabled/*;
 }
 CONFIG
@@ -223,9 +299,11 @@
     end
 
     # copy over certs for ssl
-    `cp #{APPSCALE_HOME}/.appscale/certs/cert.pem #{NGINX_PATH}`
-    `cp #{APPSCALE_HOME}/.appscale/certs/cert.key #{NGINX_PATH}`
-    
+    # just copy files once to keep certificate as static.
+    #`test ! -e #{NGINX_PATH}/mycert.pem && cp #{APPSCALE_HOME}/.appscale/certs/mycert.pem #{NGINX_PATH}`
+    #`test ! -e #{NGINX_PATH}/mykey.pem && cp #{APPSCALE_HOME}/.appscale/certs/mykey.pem #{NGINX_PATH}`
+    `cp #{APPSCALE_HOME}/.appscale/certs/mykey.pem #{NGINX_PATH}`
+    `cp #{APPSCALE_HOME}/.appscale/certs/mycert.pem #{NGINX_PATH}`
     # Write the main configuration file which sets default configuration parameters
     File.open(MAIN_CONFIG_FILE, "w+") { |dest_file| dest_file.write(config) }
   end

=== added file 'AppController/pbserver.rb'
--- AppController/pbserver.rb	1970-01-01 00:00:00 +0000
+++ AppController/pbserver.rb	2010-06-29 01:49:23 +0000
@@ -0,0 +1,106 @@
+#!/usr/bin/ruby -w
+require 'helperfunctions'
+
+# A class to wrap all the interactions with the PbServer
+class PbServer
+  APPSCALE_HOME=ENV['APPSCALE_HOME']
+  # If using just native transactions, then use one server port 
+  SERVER_PORTS = [4000, 4001, 4002]
+  # The port which nginx will use to send requests to haproxy
+  PROXY_PORT = 3999
+  # The port which requests to this app will be served from
+  LISTEN_PORT = 8888
+  LISTEN_SSL_PORT = 8443
+  # The following databases cannot have multiple pbservers
+  SINGLE_SERVER_TABLE = ["mysql"]
+  # The following databases have native transaction support
+  NATIVE_TRANSACTIONS = ["mysql"]
+  @@pb_master_ip = ""
+  @@pb_ip = ""
+  @@pb_table = ""
+  @@pb_zklocations = "" 
+
+  def self.start(master_ip, db_local_ip, my_ip, table, zklocations)
+    @@pb_master_ip = master_ip
+    @@pb_ip = my_ip
+    @@pb_table = table
+    @@pb_zklocations = zklocations 
+    ports = SERVER_PORTS
+    
+    pbserver = self.pb_script
+    ports = self.server_ports
+    ports.each { |pbserver_port|
+      cmd = [ "MASTER_IP=#{@@pb_master_ip} LOCAL_DB_IP='#{db_local_ip}'", 
+            "start-stop-daemon --start",
+            "--exec /usr/bin/python2.6",
+            "--name appscale_server",
+            "--make-pidfile",
+            "--pidfile /var/appscale/appscale-appscaleserver-#{pbserver_port}.pid",
+            "--background",
+            "--",
+            "#{pbserver}",
+            "-p #{pbserver_port}",
+            "--no_encryption",
+            "--type #{@@pb_table}",
+            "-z \"#{@@pb_zklocations}\"",
+            "-s #{HelperFunctions.get_secret}",
+            "-a #{@@pb_ip} --key"]
+      Djinn.log_debug(cmd.join(" "))
+      Kernel.system cmd.join(" ")
+      }
+  end
+
+  def self.stop
+     ports = self.server_ports
+     ports.each { |pbserver_port|
+       Kernel.system "start-stop-daemon --stop --pidfile /var/appscale/appscale-appscaleserver-#{pbserver_port}.pid"
+     }
+  end
+
+  def self.restart
+    self.stop
+    # Use cached variables
+    self.start(@@pb_master_ip, @@pb_ip, @@pb_table, @@pb_zklocations)
+  end
+
+  def self.name
+    "as_pbserver"
+  end
+
+  def self.public_directory
+    "/root/appscale/AppDB/public"
+  end
+
+  def self.listen_port
+    LISTEN_PORT
+  end
+
+  def self.listen_ssl_port
+    LISTEN_SSL_PORT
+  end
+
+  def self.server_ports
+    if SINGLE_SERVER_TABLE.include?(@@pb_table)
+      return SERVER_PORTS.first(1)
+    else
+      return SERVER_PORTS
+    end
+  end
+
+  def self.proxy_port
+    PROXY_PORT
+  end
+  
+  def self.is_running
+    `curl http://#{@@pb_ip}:#{PROXY_PORT}` 
+  end 
+
+  def self.pb_script
+    if NATIVE_TRANSACTIONS.include?(@@pb_table)
+      return "#{APPSCALE_HOME}/AppDB/appscale_server_native_trans.py"
+    else
+      return "#{APPSCALE_HOME}/AppDB/appscale_server.py"
+    end
+  end
+     
+end

=== modified file 'AppController/terminate.rb'
--- AppController/terminate.rb	2010-06-21 20:39:53 +0000
+++ AppController/terminate.rb	2010-06-29 01:49:23 +0000
@@ -28,6 +28,7 @@
 Collectd.stop
 LoadBalancer.stop
 Monitoring.stop
+PbServer.stop
 `/etc/init.d/klogd stop`
 
 `rm -rf /var/apps/`

=== modified file 'AppDB/appscale_server.py'
--- AppDB/appscale_server.py	2010-05-11 20:49:42 +0000
+++ AppDB/appscale_server.py	2010-06-29 01:49:23 +0000
@@ -5,7 +5,9 @@
 # Soo Hwan Park ([e-mail])
 # Sydney Pang ([e-mail])
 # See LICENSE file
-
+import tornado.httpserver
+import tornado.ioloop
+import tornado.web
 import sys
 import socket
 import os 
@@ -18,10 +20,7 @@
 import md5 
 import random
 import getopt
-from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
-from SocketServer import ThreadingMixIn
 import threading
-
 from google.appengine.api import api_base_pb
 from google.appengine.api import datastore
 from google.appengine.api import datastore_errors
@@ -37,8 +36,7 @@
 from M2Crypto import SSL
 from drop_privileges import *
 from zkappscale import zktransaction
-import as_transaction
-
+zk = zktransaction
 import time
 
 DEBUG = False 
@@ -48,7 +46,7 @@
 DEFAULT_APP_LOCATION = ".flatfile_apps"
 HYPERTABLE_XML_TAG = "Name"
 DEFAULT_DATASTORE = "files"
-DEFAULT_SSL_PORT = 443
+DEFAULT_SSL_PORT = 8443
 DEFAULT_PORT = 4080
 DEFAULT_ENCRYPTION = 1
 CERT_LOCATION = "/etc/appscale/certs/mycert.pem"
@@ -68,7 +66,7 @@
 KEYBLOCKSIZE = "50"
 keyDictionaryLock = None
 keyDictionary = {}
-
+MAX_DICT_SIZE = 1000000
 optimizedQuery = False
 ID_KEY_LENGTH = 64
 tableHashTable = {}
@@ -78,7 +76,6 @@
 ssl_cert_file = ""
 ssl_key_file  = ""
 
-_trans_set = as_transaction.ASTransSet()
 zoo_keeper = ""
 zoo_keeper_locations = "localhost:2181"
 
@@ -93,7 +90,6 @@
 for the entity table
 """
 
-
 class ThreadLogger:
   def __init__(self, log):
     self.logger_ = log
@@ -109,6 +105,24 @@
 logger = appscale_logger.getLogger("pb_server")
 
 
+class putThread(threading.Thread):
+  def setup(self, db, table, key, fields, values):
+    self.db = db
+    self.table = table
+    self.key = key
+    self.fields = fields
+    self.values = values
+    self.err = None
+    self.ret = None
+    self.timeTaken = 0
+  def run(self):
+    s = time.time()
+    self.err, self.ret = self.db.put_entity(self.table, self.key,
+                                       self.fields, self.values)
+    self.timeTaken = time.time() - s
+
+
+
 def getTableName(app_id, kind, version):
   return app_id + "___" + kind + "___" + version
 
@@ -240,7 +254,7 @@
       else:
         keyStart, blockSize = zoo_keeper.generateIDBlock(app_id, root)
         keyStart = long(keyStart)
-    except e:
+    except Exception, e:
        print "="*60
        print "Exception:",str(e)
        print "="*60
@@ -250,6 +264,12 @@
   key = keyStart
   keyStart = keyStart + 1
   keyDictionary[index] = keyStart, keyEnd
+
+  # To prevent the dictionary from getting to large 
+  # and taking up too much memory 
+  if len(keyDictionary) > MAX_DICT_SIZE:
+    keyDictionary = {} # reset
+
   keyDictionaryLock.release()
   return key
 
@@ -258,30 +278,18 @@
   pass
 
 
-class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
-  """ Handle requests in a new thread """
-
-
-class AppScaleSecureHandler( BaseHTTPRequestHandler ):
+
+class MainHandler(tornado.web.RequestHandler):
   """
   Defines what to do when the webserver receives different types of 
   HTTP requests.
   """
-  def get_http_err_code( self, message ):
-    print message
-    ret = 599  # 599 is the default code for an unknown error #
-    return ret
-
-  def send_post_http_response( self , http_code , message ):
-    self.send_response( http_code )
-    self.send_header( 'Content-type' , 'text/plain' )
-    self.end_headers()
-    self.wfile.write( message )
-
-  def send_http_err_response( self, err_msg ):
-    ret_http_code = self.get_http_err_code( err_msg )
-    self.send_post_http_response( ret_http_code, err_msg )
-  
+  ########################
+  # GET Request Handling #
+  ########################
+  def get(self):
+    self.write("Hi")
+ 
   # remote api request
   # sends back a response 
   def remote_request(self, app_id, appscale_version, http_request_data):
@@ -304,8 +312,6 @@
     method = apirequest.method()
     request_data = apirequest.request()
     http_request_data = request_data.contents()
-
-    print "REQUEST:",method," AT time",time.time()
     if method == "Put":
       response, errcode, errdetail = self.put_request(app_id, 
                                                  appscale_version, 
@@ -393,8 +399,7 @@
       print "REPLY",method," AT TIME",time.time()
       print "errcode:",errcode
       print "errdetail:",errdetail
-    self.send_post_http_response( 200 , apiresponse.Encode() )    
-
+    self.write( apiresponse.Encode() )    
 
   def run_query(self, app_id, appscale_version, http_request_data):
     global app_datastore
@@ -404,14 +409,7 @@
     if query.has_transaction():
       txn = query.transaction()
 
-      if not _trans_set.isValid(txn):
-        _trans_set.purge(txn)
-        return (api_base_pb.VoidProto().Encode(),
-                datastore_pb.Error.BAD_REQUEST,
-                'Transaction timed out.')
-                
       if not query.has_ancestor():
-        _trans_set.purge(txn)
         return (api_base_pb.VoidProto().Encode(),
                 datastore_pb.Error.BAD_REQUEST,
                 'Only ancestor queries are allowed inside transactions.')
@@ -424,22 +422,12 @@
                 datastore_pb.Error.BAD_REQUEST,
                 'No group entity or root key.')
  
-      if _trans_set.needsLock(txn):
+      try:
         gotLock= zoo_keeper.acquireLock( app_id, txn.handle(), root_key)
-        if gotLock:
-          _trans_set.setGroup(txn, root_key) 
-        else:
-          _trans_set.purge(txn)
+      except zk.ZKTransactionException, zkex:
           return (api_base_pb.VoidProto().Encode(),
                  datastore_pb.Error.CONCURRENT_TRANSACTION,
-                 'Another transaction is running.')
-      else:
-        if _trans_set.hasLockExpired(txn):          
-          #zoo_keeper.notifyOfExpiredLock(app_id, root_key) 
-          _trans_set.purge(txn)
-          return (api_base_pb.VoidProto().Encode(),
-                  datastore_pb.Error.TIMEOUT,
-                  'The transaction lease has expired.')
+                 'Another transaction is running. %s'%zkex.message)
                   
     if not query.has_kind():
       # Return nothing in case of error #
@@ -448,20 +436,15 @@
               "Kindless queries are not implemented.")
     else:
       kind = query.kind()
-      #print "Query kind:",kind
-
-      # Verify validity of the entity name and applicaiton id #
-      # according to the naming sheme for entity tables #
-      #assert kind[-2:] != "__"
-      #assert app_id[-1] != "_"
-
       # Fetch query from the datastore # 
       table_name = getTableName(app_id, kind, appscale_version)
-      #print "Query using table name: %s, %s" % (table_name, ENTITY_TABLE_SCHEMA)
       r = app_datastore.get_table( table_name, ENTITY_TABLE_SCHEMA)
-      #print "result: %s" % str(r)
+      err = r[0]
+      if err not in ERROR_CODES: 
+        return (api_base_pb.VoidProto().Encode(),
+              datastore_pb.Error.INTERNAL_ERROR,
+              "Error running query--." + err)
 
-      #err = r[0]
       if len(r) > 1:
         results = r[1:]
       else:
@@ -471,8 +454,6 @@
       versions = results[1::2]
       # evens are encoded entities
       results = results[0::2]  
-      #print "RESULTS:",results
-      #print "VERSIONS:",versions
       if len(versions) != len(results):
         return(api_base_pb.VoidProto().Encode(),
                datastore_pb.Error.INTERNAL_ERROR,
@@ -498,7 +479,6 @@
           row_key = getRowKeyFromDeletedEncoding(encoded_ent)
         else:
           row_key = getRowKeyFromKeyType(app_id, encoded_ent.key()) 
-          #print "constructed row key:",row_key
           root_key = self.getRootKeyFromEntity(app_id, encoded_ent)
 
         #TODO  make sure all deleted keys use the same encoding
@@ -509,8 +489,6 @@
           journal_result = ["DB_ERROR:",DELETED]
         elif prev_version != long(ii):
           # if the versions don't match, a valid version must be fetched
-          print "previous version from zk:",prev_version
-          print "prev version:",str(ii)
           journal_key = getJournalKey(row_key, prev_version)
           journal_table = getJournalTable(app_id, appscale_version)
           journal_result = app_datastore.get_entity( journal_table, 
@@ -638,59 +616,24 @@
     transaction_pb = datastore_pb.Transaction()
     # handle = zk.getTransactionID(app_id)
     handle = zoo_keeper.getTransactionID(app_id)
-    print "Begin Trans Handle:",handle
     transaction_pb.set_handle(handle)
-    _trans_set.add(transaction_pb)
     return (transaction_pb.Encode(), 0, "")
 
   def commit_transaction_request(self, app_id, appscale_version, http_request_data):
     txn =  datastore_pb.Transaction(http_request_data)
     commitres_pb = datastore_pb.CommitResponse()
-    if not _trans_set.isValid(txn):
-      _trans_set.purge(txn)
-      return (commitres_pb.Encode(),
-              datastore_pb.Error.BAD_REQUEST,
-             'Transaction timed out.')
 
-    if _trans_set.needsLock(txn):
-      _trans_set.purge(txn)
-      return (commitres_pb.Encode(), 
-             datastore_pb.Error.BAD_REQUEST,
-             'Commiting without owning the group lock.')
-   
-    # if zk.releaseLock(app_id, txn.handle()):
-    #try:
     if zoo_keeper.releaseLock(app_id, txn.handle()):
-      _trans_set.purge(txn)
       return (commitres_pb.Encode(), 0, "")
     else:
       # ZK client must now deal with lock
       return (commitres_pb.Encode(), 
              datastore_pb.Error.INTERNAL_ERROR,
              "Unable to release lock")
-    #except :
-    #  print "exception:",str(ii)
-    #  return (commitres_pb.Encode(),
-    #          datastore_pb.Error.INTERNAL_ERROR,
-    #          "Releasing a lock with the wrong group")
-
 
   def rollback_transaction_request(self, app_id, appscale_version, http_request_data):
     txn =  datastore_pb.Transaction(http_request_data)
     zoo_keeper.notifyFailedTransaction(app_id, txn.handle())
-    print "ROLLBACK for transaction:",txn.handle()
-    if not _trans_set.isValid(txn):
-      _trans_set.purge(txn)
-      return (api_base_pb.VoidProto().Encode(),
-              datastore_pb.Error.BAD_REQUEST,
-             'Transaction timed out.')
-    if _trans_set.needsLock(txn):
-      _trans_set.purge(txn)
-      return (api_base_pb.VoidProto().Encode(), 
-             datastore_pb.Error.BAD_REQUEST,
-             'Rolling back without owning the group lock.')
-
-    _trans_set.purge(txn)
     return (api_base_pb.VoidProto().Encode(), 0, "")
 
 
@@ -766,7 +709,6 @@
     if not request.has_transaction():
       rollback_req = datastore_pb.Transaction()
       rollback_req.set_handle(internal_txn)
-      #print "ROLLING BACK FOR %s" % internal_txn
       self.rollback_transaction_request(app_id, 
                                         "version", 
                                         rollback_req.Encode())
@@ -806,12 +748,8 @@
       # Only dealing with root puts
       if e.key().path().element_size() == 1:
         root_path = e.key().path().mutable_element(0)
-        #print "has id:",root_path.has_id(), "has name:",root_path.has_name()
         if root_path.id() == 0 and not root_path.has_name():
-          #   zk.generateIDBlock(self, app_id, entity_key = GLOBAL_ID_KEY):
-          #new_key = root_key + "/" + last_path.type()
           uid = generate_unique_id(app_id, None, None)
-          print "Assigned uid to new root key:",str(uid)
           if uid <= 0:
             return (putresp_pb.Encode(), 
                     datastore_pb.Error.INTERNAL_ERROR,
@@ -819,36 +757,22 @@
           root_path.set_id(uid)
 
     if putreq_pb.has_transaction():
-      #print "This put has transaction"
       txn = putreq_pb.transaction()
 
-      if not _trans_set.isValid(txn):
-        #_trans_set.purge(txn)
-        return (putresp_pb.Encode(),
-                datastore_pb.Error.BAD_REQUEST,
-                'Transaction timed out.')
       
       root_key, errcode, errdetail = self.getRootKeyFromTransPut(app_id, putreq_pb)
       if errcode != 0:
-        #_trans_set.purge(txn)
         return (putresp_pb.Encode(), 
                 errcode,
                 errdetail)
-      #print "Root key: ",root_key 
-      if _trans_set.needsLock(txn):
-        # zk.acquireLock(app_id, txn.handle())
+      try:
         gotLock = zoo_keeper.acquireLock( app_id, txn.handle(), root_key)
-        if gotLock:
-          _trans_set.setGroup(txn, root_key) 
-        else:
-          #_trans_set.purge(txn)
-          return (putresp_pb.Encode(),
-                 datastore_pb.Error.CONCURRENT_TRANSACTION,
-                 'Another transaction is running.')
+      except zk.ZKTransactionException, zkex:
+        return (putresp_pb.Encode(),
+                datastore_pb.Error.CONCURRENT_TRANSACTION,
+                'Error trying to acquire lock. %s'%zkex.message)
 
     # Gather data from Put Request #
-    #print "Entity list for put:"
-    #print putreq_pb.entity_list()
     for e in putreq_pb.entity_list():
 
       for prop in e.property_list() + e.raw_property_list():
@@ -904,7 +828,6 @@
       # All writes are transactional and per entity if 
       # not already wrapped in a transaction
       if not putreq_pb.has_transaction():
-        #print "This is not a composite transaction"
         txn, err, errcode = self.begin_transaction_request(app_id,
                                                  appscale_version,
                                                  http_request_data)
@@ -912,33 +835,24 @@
         txn = datastore_pb.Transaction(txn)
 
         if err != 0:
-          _trans_set.purge(txn)
           return (putresp_pb.Encode(), err, errcode)
         root_key = getRootKey(app_id, e.key().path().element_list())
-        # TODO what if this is a new key and does not have a uid
         if root_key == None:
           self.maybe_rollback_transaction(app_id, putreq_pb, txn.handle())
           return (putresp_pb.Encode(),
                   datastore_pb.Error.BAD_REQUEST,
                   'No group entity or root key.')
-                  
-        #print "Root key: ",root_key 
-        if _trans_set.needsLock(txn):
-          #print "needs lock"
+        try:          
           gotLock = zoo_keeper.acquireLock( app_id, txn.handle(), root_key)
-          if gotLock:
-            _trans_set.setGroup(txn, root_key) 
-          else:
-            #_trans_set.purge(txn)
-            self.maybe_rollback_transaction(app_id, putreq_pb, txn.handle())
-            return (putresp_pb.Encode(),
-                   datastore_pb.Error.CONCURRENT_TRANSACTION,
-                   'Another transaction is running.')
+        except zk.ZKTransactionException, zkex:
+          self.maybe_rollback_transaction(app_id, putreq_pb, txn.handle())
+          return (putresp_pb.Encode(),
+                  datastore_pb.Error.CONCURRENT_TRANSACTION,
+                  'Another transaction is running %s.'%zkex.message)
       #######################################
       # Done with key assignment
       # Notify Soap Server of any new tables
       #######################################
-      #print "Putting of type:",kind,"with uid of",str(uid)
       # insert key 
       table_name = getTableName(app_id, kind, appscale_version)
       #print "Put Using table name:",table_name
@@ -991,59 +905,42 @@
                                                       row_key)
  
       try:
-        print "Using handle for put:",txn.handle()
         zoo_keeper.registUpdatedKey(app_id, txn.handle(), prev_version, row_key)
       except e:
-        print "Exception thrown by register update key",str(e)
         self.maybe_rollback_transaction(app_id, putreq_pb, txn.handle())
         return (putresp_pb.Encode(),
                 datastore_pb.Error.INTERNAL_ERROR,
                 "Timeout: Unable to update ZooKeeper on change set for transaction")
-
+      journalPut = putThread()
       journal_key = getJournalKey(row_key, txn.handle())
-      
-      field_name_list = JOURNAL_SCHEMA
-      field_value_list = [e.Encode()]
       journal_table = getJournalTable(app_id, appscale_version)
-      print "Putting to ",journal_table,"key:",journal_key
-      err, res = app_datastore.put_entity( journal_table,
-                                           journal_key,
-                                           field_name_list,
-                                           field_value_list )
-
-      if err not in ERROR_CODES:
-        #_trans_set.purge(txn)
-        self.maybe_rollback_transaction(app_id, putreq_pb, txn.handle())
-        return (putresp_pb.Encode(),
-                datastore_pb.Error.INTERNAL_ERROR,
-                err + ", Unable to write to journal")
+      journalPut.setup(app_datastore,
+                       journal_table,
+                       journal_key,
+                       JOURNAL_SCHEMA,
+                       [e.Encode()])
+      entPut = putThread()
+      entPut.setup(app_datastore,
+                       table_name,
+                       row_key,
+                       ENTITY_TABLE_SCHEMA,
+                       [e.Encode(), str(txn.handle())])
+      journalPut.start()
+      entPut.start()
+      journalPut.join()
+      entPut.join()
+      if journalPut.err not in ERROR_CODES:
+        self.maybe_rollback_transaction(app_id, putreq_pb, txn.handle())
+        return (putresp_pb.Encode(),
+                datastore_pb.Error.INTERNAL_ERROR,
+                journalPut.err + ", Unable to write to journal")
+      if entPut.err not in ERROR_CODES:
+        self.maybe_rollback_transaction(app_id, putreq_pb, txn.handle())
+        return (putresp_pb.Encode(),
+                datastore_pb.Error.INTERNAL_ERROR,
+                entPut.err + ", Unable to write to journal")
       
-      field_name_list = ENTITY_TABLE_SCHEMA
-      field_value_list =  [e.Encode(), str(txn.handle())]
-      #print "put entity field name: %s, field value: %s" % (str(field_name_list), str(field_value_list))
-      err, res = app_datastore.put_entity( table_name, 
-                                           row_key, 
-                                           field_name_list, 
-                                           field_value_list)
-
-      if err not in ERROR_CODES:
-        #_trans_set.purge(txn)
-        self.maybe_rollback_transaction(app_id, putreq_pb, txn.handle())
-        return (putresp_pb.Encode(),
-                datastore_pb.Error.INTERNAL_ERROR,
-                err)
-
-      # RANDOM ERRORS   
-      """
-      rand = random.random()
-      rand = int(rand * 10000)
-      if rand % 100 == 0:
-        self.maybe_rollback_transaction(app_id, putreq_pb, txn.handle())
-        print "RANDOM ERROR!!!"
-        return(putresp_pb.Encode(),
-               datastore_pb.Error.BAD_REQUEST,
-               'Random Error.')
-      """
+
       if not putreq_pb.has_transaction():
         com_res, errcode, errdetail = self.commit_transaction_request(app_id, 
                                                                       appscale_version, 
@@ -1068,28 +965,18 @@
     if getreq_pb.has_transaction():
       txn = getreq_pb.transaction()
 
-      if not _trans_set.isValid(txn):
-        _trans_set.purge(txn)
-        return (getresp_pb.Encode(),
-                datastore_pb.Error.BAD_REQUEST,
-                'Transaction timed out.')
-      
       root_key, errcode, errdetail = self.getRootKeyFromTransGet(app_id,getreq_pb)
       if errcode != 0:
-        _trans_set.purge(txn)
         return (getresp_pb.Encode(), 
                 errcode,
                 errdetail)
       
-      if _trans_set.needsLock(txn):
+      try:
         gotLock= zoo_keeper.acquireLock( app_id, txn.handle(), root_key)
-        if gotLock:
-          _trans_set.setGroup(txn, root_key) 
-        else:
-          _trans_set.purge(txn)
-          return (getresp_pb.Encode(),
-                 datastore_pb.Error.CONCURRENT_TRANSACTION,
-                 'Another transaction is running.')           
+      except zk.ZKTransactionException, zkex:
+        return (getresp_pb.Encode(),
+                datastore_pb.Error.CONCURRENT_TRANSACTION,
+                'Another transaction is running. %s'%zkex.message)           
        
     for key in getreq_pb.key_list():
       key.set_app(app_id)
@@ -1106,7 +993,6 @@
       logger.debug("get: %s___%s___%s %s" % (app_id, kind, appscale_version, str(entity_id)))
       table_name = getTableName(app_id, kind, appscale_version)
       row_key = getRowKey(app_id,key.path().element_list())
-      print "Get row key:",row_key
       r = app_datastore.get_entity( table_name, row_key, ENTITY_TABLE_SCHEMA )
       err = r[0]
       if err not in ERROR_CODES or len(r) != 3: 
@@ -1128,23 +1014,18 @@
                                                    prev_version, 
                                                    row_key)
       if valid_txn != prev_version: 
-        print "Using journal version",valid_txn," versus invalid:",prev_version
         prev_version = valid_txn
         if prev_version == long(NONEXISTANT_TRANSACTION):
           entity = None
         else:
           journal_table = getJournalTable(app_id, appscale_version)
           journal_key = getJournalKey(row_key, prev_version)
-          print "Retriving from ",journal_table,"key:",journal_key
           r = app_datastore.get_entity(journal_table, journal_key, ENTITY_TABLE_SCHEMA[:1] )  
           err = r[0]
           if err not in ERROR_CODES or len(r) != 2:
-            print r
-            print "UNABLE TO GET JOURNAL VERSION"
             r = ["",DELETED]
 
           if len(r) > 1:
-            print "GOT JOURNAL VERSION"
             entity = r[1]
  
       if entity[0:len(DELETED)] == DELETED:
@@ -1156,7 +1037,6 @@
         group.mutable_entity().CopyFrom(e_pb)
         
     # Send Response #
-    print getresp_pb
     logger.debug("GET_RESPONSE: %s" % getresp_pb)
     return (getresp_pb.Encode(), 0, "")
 
@@ -1174,31 +1054,19 @@
     logger.debug("DELETE_REQUEST: %s" % delreq_pb)
     delresp_pb = api_base_pb.VoidProto() 
     if delreq_pb.has_transaction():
-      print "This delete has a transaction"
       txn = delreq_pb.transaction()
 
-      if not _trans_set.isValid(txn):
-        #_trans_set.purge(txn)
-        return (delresp_pb.Encode(),
-                datastore_pb.Error.BAD_REQUEST,
-                'Transaction timed out.')
-      
       root_key, errcode, errdetail = self.getRootKeyFromTransDel(app_id, delreq_pb)
       if errcode != 0:
-        #_trans_set.purge(txn)
         return (delresp_pb.Encode(), 
                 errcode,
                 errdetail)
-      if _trans_set.needsLock(txn):
-        # zk.acquireLock(app_id, txn.handle())
+      try:
         gotLock = zoo_keeper.acquireLock( app_id, txn.handle(), root_key)
-        if gotLock:
-          _trans_set.setGroup(txn, root_key) 
-        else:
-          #_trans_set.purge(txn)
-          return (delresp_pb.Encode(),
-                 datastore_pb.Error.CONCURRENT_TRANSACTION,
-                 'Another transaction is running.')
+      except zk.ZKTransactionException, zkex:
+        return (delresp_pb.Encode(),
+                datastore_pb.Error.CONCURRENT_TRANSACTION,
+                'Another transaction is running. %s'%zkex.message)
 
 
     for key in delreq_pb.key_list():
@@ -1212,7 +1080,6 @@
       # All deletes are transactional and per entity if 
       # not already wrapped in a transaction
       if not delreq_pb.has_transaction():
-        print "This is not a composite transaction"
         txn, err, errcode = self.begin_transaction_request(app_id,
                                                  appscale_version,
                                                  http_request_data)
@@ -1220,7 +1087,6 @@
         txn = datastore_pb.Transaction(txn)
 
         if err != 0:
-          _trans_set.purge(txn)
           return (delresp_pb.Encode(), err, errcode)
         root_key = getRootKey(app_id, key.path().element_list())
         if root_key == None:
@@ -1233,15 +1099,13 @@
         # Get a lock for the group
         # Do a read before a write to get the old values
         ################################################
-        gotLock = zoo_keeper.acquireLock( app_id, txn.handle(), root_key)
-        if gotLock:
-          _trans_set.setGroup(txn, root_key) 
-        else:
-          #_trans_set.purge(txn)
+        try:
+          gotLock = zoo_keeper.acquireLock( app_id, txn.handle(), root_key)
+        except zk.ZKTransactionException, zkex:
           self.maybe_rollback_transaction(app_id, delreq_pb, txn.handle())
           return (delresp_pb.Encode(),
                   datastore_pb.Error.CONCURRENT_TRANSACTION,
-                  'Another transaction is running.')
+                  'Another transaction is running. %s'%zkex.message)
 
       ##########################
       # Get the previous version
@@ -1292,7 +1156,6 @@
                                            field_value_list )
 
       if err not in ERROR_CODES:
-        #_trans_set.purge(txn)
         self.maybe_rollback_transaction(app_id, delreq_pb, txn.handle())
         return (delresp_pb.Encode(),
                 datastore_pb.Error.INTERNAL_ERROR,
@@ -1416,31 +1279,18 @@
     print "http done"
     self.void_proto(app_id, appscale_version, http_request_data)
 
-  ########################
-  # GET Request Handling #
-  ########################
-  def do_GET( self ):
-    self.send_error( 404 , 'File Not Found: %s' % self.path )
   
   #########################
   # POST Request Handling #
   #########################
-  def do_POST( self ):
-    start_time = time.time() 
-    http_request_data = self.rfile.read(int(self.headers.getheader('content-length')))
-    inter_time = time.time()
-    logger.debug("Timing for pre pre env setup:" + " " + 
-                 str(start_time) + " " + str(inter_time) + 
-                 " total time: " + str(inter_time - start_time) + "\n")
-    print "intertime - starttime:",(str(inter_time - start_time))
-    pb_type = self.headers.getheader( 'protocolbuffertype' )  
-    app_data = self.headers.getheader('appdata')
+  @tornado.web.asynchronous
+  def post( self ):
+    request = self.request
+    http_request_data = request.body
+    pb_type = request.headers['protocolbuffertype']   
+    app_data = request.headers['appdata']
     app_data  = app_data.split(':')
     logger.debug("POST len: %d" % len(app_data))
-    inter_time = time.time()
-    logger.debug("Timing for pre env setup:" + " " + 
-                 str(start_time) + " " + str(inter_time) + 
-                 " total time: " + str(inter_time - start_time) + "\n") 
 
     if len(app_data) == 5:
       app_id, user_email, nick_name, auth_domain, appscale_version = app_data
@@ -1470,42 +1320,12 @@
     # Default HTTP Response Data #
     logger.debug("For app id: " + app_id)
     logger.debug("For app version: " + appscale_version)
-    inter_time = time.time()
-    logger.debug("Timing for env setup:" + pb_type + " " + 
-                 app_id + " " + str(start_time) + " " + 
-                 str(inter_time) + " total time: " + str(inter_time - start_time) + "\n") 
 
     if pb_type == "Request":
       self.remote_request(app_id, appscale_version, http_request_data)
     else:
       self.unknown_request(app_id, appscale_version, http_request_data, pb_type)
-    
-    stop_time = time.time()
-
-    #if logOn == True:
-    #logFilePtr.write(pb_type + " " + app_id + " " + 
-    #str(start_time) + " " + str(stop_time) + " total time: " + 
-    #str(stop_time - start_time) + "\n") 
-      
-    logger.debug(pb_type + " " + app_id + " " + str(start_time) + " " + 
-                 str(stop_time) + " total time: " + str(stop_time - start_time) + "\n") 
-        
-class AppScaleUnSecureServerThreaded( ThreadingMixIn, HTTPServer):
-  pass
-
-class AppScaleSecureServerThreaded( ThreadingMixIn, HTTPServer ):
-  def __init__( self):
-    global local_server_address
-    global HandlerClass
-    global ssl_cert_file
-    global ssl_key_file  
-    BaseServer.__init__( self, local_server_address, HandlerClass )
-    ctx = SSL.Context()
-    ctx.load_cert( ssl_cert_file, ssl_key_file )
-    self.socket = SSL.Connection( ctx )
-    self.server_bind()
-    self.server_activate()
-    
+    self.finish() 
 def usage():
   print "AppScale Server" 
   print
@@ -1518,6 +1338,11 @@
   print "\t--blocksize=<key-block-size>"
   print "\t--optimized_query"
   print "\t--no_encryption"
+
+pb_application = tornado.web.Application([
+    (r"/*", MainHandler),
+])        
+
 def main(argv):
   global app_datastore
   global getKeyFromServer
@@ -1599,43 +1424,23 @@
     exit(1)
 
   tableServer = SOAPpy.SOAPProxy("https://" + soapServer + ":" + str(keyPort))
-  
- # # Bind Port #
-  #server = AppScaleSecureServer( ('',DEFAULT_SSL_PORT), 
-  #                              AppScaleSecureHandler, cert_file, key_file )
-  #help(ThreadedHTTPServer)
-  global local_server_address
-  global HandlerClass
-  global ssl_cert_file
-  global ssl_key_file  
   global keyDictionaryLock 
 
   zoo_keeper = zktransaction.ZKTransaction(zoo_keeper_locations)
   keyDictionaryLock = threading.Lock()
   if port == DEFAULT_SSL_PORT and not isEncrypted:
     port = DEFAULT_PORT
-  local_server_address = ('',port)
-  HandlerClass = AppScaleSecureHandler
-  ssl_cert_file = cert_file
-  ssl_key_file = key_file 
-  if isEncrypted:
-    server = AppScaleSecureServerThreaded()
-  else:
-    server = AppScaleUnSecureServerThreaded(local_server_address, HandlerClass)  
-  sa = server.socket.getsockname()
-  if not db_type == "timesten":
-    # Stop running as root, security purposes #
-    drop_privileges()
-  logger.debug("\n\nStarting AppScale-Secure-Server on %s:%s" % (sa[0], sa[1]))
+  server = tornado.httpserver.HTTPServer(pb_application)
+  server.listen(port)
 
   while 1:
     try:
       # Start Server #
-      server.serve_forever()
+      tornado.ioloop.IOLoop.instance().start()
     except SSL.SSLError:
-      logger.debug("\n\nUnexcepted input for AppScale-Secure-Server on %s:%s" % (sa[0], sa[1]))
+      logger.debug("\n\nUnexcepted input for AppScale-Secure-Server")
     except KeyboardInterrupt:
-      server.socket.close() 
+      #server.socket.close() 
       print "Server interrupted by user, terminating..."
       exit(1)
 

=== added file 'AppDB/appscale_server_native_trans.py'
--- AppDB/appscale_server_native_trans.py	1970-01-01 00:00:00 +0000
+++ AppDB/appscale_server_native_trans.py	2010-06-29 01:49:23 +0000
@@ -0,0 +1,1086 @@
+#!/usr/bin/python
+#
+# Author: 
+# Navraj Chohan ([e-mail])
+# Soo Hwan Park ([e-mail])
+# Sydney Pang ([e-mail])
+# See LICENSE file
+import tornado.httpserver
+import tornado.ioloop
+import tornado.web
+
+import sys
+import socket
+import os 
+import types
+import appscale_datastore
+#import helper_functions
+import SOAPpy
+from dbconstants import *
+import appscale_logger
+import md5 
+import random
+import getopt
+import threading
+
+from google.appengine.api import api_base_pb
+from google.appengine.api import datastore
+from google.appengine.api import datastore_errors
+from google.appengine.api import datastore_types
+from google.appengine.api import users
+from google.appengine.datastore import datastore_pb
+from google.appengine.datastore import datastore_index
+from google.appengine.runtime import apiproxy_errors
+from google.net.proto import ProtocolBuffer
+from google.appengine.datastore import entity_pb
+from google.appengine.ext.remote_api import remote_api_pb
+from SocketServer import BaseServer
+from M2Crypto import SSL
+from drop_privileges import *
+from zkappscale import zktransaction
+
+import time
+
+DEBUG = False 
+APP_TABLE = APPS_TABLE
+USER_TABLE = USERS_TABLE
+DEFAULT_USER_LOCATION = ".flatfile_users"
+DEFAULT_APP_LOCATION = ".flatfile_apps"
+HYPERTABLE_XML_TAG = "Name"
+DEFAULT_DATASTORE = "files"
+DEFAULT_SSL_PORT = 8443
+DEFAULT_PORT = 4080
+DEFAULT_ENCRYPTION = 1
+CERT_LOCATION = "/etc/appscale/certs/mycert.pem"
+KEY_LOCATION = "/etc/appscale/certs/mykey.pem"
+SECRET_LOCATION = "/etc/appscale/secret.key"
+VALID_DATASTORES = []
+ERROR_CODES = []
+app_datastore = []
+logOn = False
+logFilePtr = ""
+zoo_keeper = ""
+
+getKeyFromServer = False
+soapServer = "localhost"
+tableServer = ""
+keyPort = 4343
+keySecret = ""
+KEYBLOCKSIZE = "50"
+keyDictionaryLock = None
+keyDictionary = {}
+
+optimizedQuery = False
+ID_KEY_LENGTH = 64
+tableHashTable = {}
+
+local_server_address = ""
+HandlerClass = ""
+ssl_cert_file = ""
+ssl_key_file  = ""
+
+DELETED = "DELETED___"
+""" 
+Deleted keys are DELETED/<row_key>
+"""
+
+""" 
+keys for tables take the format
+appname/Grandparent:<ID>/Parent:<ID>/Child:<ID>
+for the entity table
+"""
+
+
+class ThreadLogger:
+  def __init__(self, log):
+    self.logger_ = log
+    self.log_lock = threading.Lock()
+
+  def debug(self, string):
+    return
+    self.log_lock.acquire()
+    print string
+    self.logger_.info(string)
+    self.log_lock.release()
+
+logger = appscale_logger.getLogger("pb_server")
+
+
+def getTableName(app_id, kind, version):
+  return app_id + "___" + kind + "___" + version
+
+def getRowKey(app_id, ancestor_list):
+  if ancestor_list == None:
+    logger.debug("Generate row key received null ancestor list")
+    return ""
+
+  key = app_id 
+
+  # Note: mysql cannot have \ as the first char in the row key
+  for a in ancestor_list:
+    key += "/" 
+    if a.has_type():
+      key += a.type()
+
+    if a.has_id():
+      zero_padded_id = ("0" * (ID_KEY_LENGTH - len(str(a.id())))) + str(a.id())
+      key += ":" + zero_padded_id
+    elif a.has_name():
+      # append _ if the name is a number, prevents collisions of key names
+      if a.name().isdigit():
+        key += ":__key__" + a.name()
+      else: 
+        key += ":" + a.name()
+  return key
+
+
+def getRootKey(app_id, ancestor_list):
+  key = app_id # mysql cannot have \ as the first char in the row key
+  a = ancestor_list[0]
+  key += "/"
+
+  # append _ if the name is a number, prevents collisions of key names
+  if a.has_type():
+    key += a.type()
+  else:
+    return None
+
+  if a.has_id():
+    zero_padded_id = ("0" * (ID_KEY_LENGTH - len(str(a.id())))) + str(a.id())
+    key += ":" + zero_padded_id
+  elif a.has_name():
+    if a.name().isdigit():
+      key += ":__key__" + a.name()
+    else: 
+      key += ":" + a.name()
+  else:
+    return None
+
+  return key
+
+
+def getRootKeyFromKeyType(app_id, key):
+  ancestor_list = key._Key__reference.path().element_list()
+  return getRootKey(app_id, ancestor_list)
+
+
+def getRowKeyFromKeyType(app_id, key):
+  ancestor_list = key._Key__reference.path().element_list()
+  return getRowKey(app_id, ancestor_list)
+
+def generate_unique_id(app_id, root, isChild):
+  global keyDictionary
+  global keyDictionaryLock
+
+  if isChild:
+    if not root:
+      return -1
+
+  index = None
+  if isChild:
+    index = app_id + "/" + str(root)
+  else:
+    index = app_id
+
+  keyDictionaryLock.acquire()
+  try:
+    keyStart, keyEnd = keyDictionary[index]
+  except:
+    keyStart = 0
+    keyEnd = 0
+
+  key = 0
+  if keyStart != keyEnd:
+    key = keyStart
+    keyStart = keyStart + 1
+    keyDictionary[index]= keyStart, keyEnd
+    keyDictionaryLock.release()
+    return key
+  else:
+    try:
+      if not isChild:
+        keyStart, blockSize = zoo_keeper.generateIDBlock(app_id)
+        keyStart = long(keyStart)
+      else:
+        keyStart, blockSize = zoo_keeper.generateIDBlock(app_id, root)
+        keyStart = long(keyStart)
+    except:
+       print "="*60
+       print "Exception: when getting id block"
+       print "="*60
+       keyDictionaryLock.release()
+       return -1
+  keyEnd = keyStart + long(blockSize)
+  key = keyStart
+  keyStart = keyStart + 1
+  keyDictionary[index] = keyStart, keyEnd
+  keyDictionaryLock.release()
+  return key
+
+  
+def getRootKeyFromRef(app_id, ref):
+  if not ref.has_path():
+    return False
+  path = ref.path()
+  element_list = path.element_list()
+  return  getRootKey(app_id, element_list)
+
+
+def rollback_function(app_id, trans_id, root_key, change_set):
+  pass
+
+
+
+
+class MainHandler(tornado.web.RequestHandler):
+  """
+  Defines what to do when the webserver receives different types of 
+  HTTP requests.
+  """
+  @tornado.web.asynchronous
+  def get(self):
+    self.write("Hi")
+    self.finish() 
+  # remote api request
+  # sends back a response 
+  def remote_request(self, app_id, appscale_version, http_request_data):
+    apirequest = remote_api_pb.Request(http_request_data)
+    apiresponse = remote_api_pb.Response()
+    response = None
+    errcode = 0
+    errdetail = "" 
+    apperror_pb = None 
+
+    if not apirequest.has_method(): 
+      errcode = datastore_pb.Error.BAD_REQUEST
+      errdetail = "Method was not set in request"
+      apirequest.set_method("NOT_FOUND")
+    if not apirequest.has_request():
+      errcode = datastore_pb.Error.BAD_REQUEST
+      errdetail = "Request missing in call"
+      apirequest.set_method("NOT_FOUND")
+      apirequest.clear_request()
+    method = apirequest.method()
+    request_data = apirequest.request()
+    http_request_data = request_data.contents()
+
+    #print "REQUEST:",method," AT time",time.time()
+    if method == "Put":
+      response, errcode, errdetail = self.put_request(app_id, 
+                                                 appscale_version, 
+                                                 http_request_data)
+    elif method == "Get":
+      response, errcode, errdetail = self.get_request(app_id, 
+                                                 appscale_version, 
+                                                 http_request_data)
+    elif method == "Delete": 
+      response, errcode, errdetail = self.delete_request(app_id, 
+                                                    appscale_version, 
+                                                    http_request_data)
+    elif method == "RunQuery":
+      response, errcode, errdetail = self.run_query(app_id, 
+                                          appscale_version, 
+                                          http_request_data)
+    elif method == "BeginTransaction":
+      response, errcode, errdetail = self.begin_transaction_request(app_id, 
+                                                      appscale_version, 
+                                                      http_request_data)
+    elif method == "Commit":
+      response, errcode, errdetail = self.commit_transaction_request(app_id, 
+                                                      appscale_version,
+                                                      http_request_data)
+    elif method == "Rollback":
+      response, errcode, errdetail = self.rollback_transaction_request(app_id, 
+                                                        appscale_version,
+                                                        http_request_data)
+    elif method == "AllocateIds":
+      response, errcode, errdetail = self.allocate_ids_request(app_id, 
+                                                appscale_version,
+                                                http_request_data)
+    elif method == "CreateIndex":
+      errcode = datastore_pb.Error.PERMISSION_DENIED
+      errdetail = "Create Index is not implemented" 
+      logger.debug(errdetail)
+      """
+      response, errcode, errdetail = self.create_index_request(app_id, 
+                                                appscale_version,
+                                                http_request_data)
+      """
+    elif method == "GetIndices":
+      errcode = datastore_pb.Error.PERMISSION_DENIED 
+      errdetail = "GetIndices is not implemented" 
+      logger.debug(errdetail)
+      """
+      response, errcode, errdetail = self.get_indices_request(app_id, 
+                                               appscale_version,
+                                               http_request_data)
+      """
+    elif method == "UpdateIndex":
+      errcode = datastore_pb.Error.PERMISSION_DENIED 
+      errdetail = "UpdateIndex is not implemented" 
+      logger.debug(errdetail)
+      """
+      response, errcode, errdetail = self.update_index_request(app_id, 
+                                                appscale_version,
+                                                http_request_data)
+      """
+    elif method == "DeleteIndex":
+      errcode = datastore_pb.Error.PERMISSION_DENIED 
+      errdetail = "DeleteIndex is not implemented" 
+      logger.debug(errdetail)
+
+      """
+      response, errcode, errdetail = self.delete_index_request(app_id, 
+                                                appscale_version,
+                                                http_request_data)
+      """
+    else:
+      errcode = datastore_pb.Error.BAD_REQUEST 
+      errdetail = "Unknown datastore message" 
+      logger.debug(errdetail)
+    
+      
+    rawmessage = apiresponse.mutable_response()
+    if response:
+      rawmessage.set_contents(response)
+
+    if errcode != 0:
+      apperror_pb = apiresponse.mutable_application_error()
+      apperror_pb.set_code(errcode)
+      apperror_pb.set_detail(errdetail)
+    if errcode != 0:
+      print "REPLY",method," AT TIME",time.time()
+      print "errcode:",errcode
+      print "errdetail:",errdetail
+    self.write(apiresponse.Encode() )    
+
+
+  def run_query(self, app_id, appscale_version, http_request_data):
+    global app_datastore
+    query = datastore_pb.Query(http_request_data)
+    logger.debug("QUERY:%s" % query)
+    results = []
+                      
+    if not query.has_kind():
+      # Return nothing in case of error #
+      return (api_base_pb.VoidProto().Encode(),
+              datastore_pb.Error.PERMISSION_DENIED,
+              "Kindless queries are not implemented.")
+    else:
+      kind = query.kind()
+      #print "Query kind:",kind
+
+      # Verify validity of the entity name and applicaiton id #
+      # according to the naming sheme for entity tables #
+      #assert kind[-2:] != "__"
+      #assert app_id[-1] != "_"
+
+      # Fetch query from the datastore # 
+      table_name = getTableName(app_id, kind, appscale_version)
+      #print "Query using table name:",table_name
+      if query.has_transaction():
+        txn = query.transaction()
+        r = app_datastore.get_table( table_name, ENTITY_TABLE_SCHEMA, txn.handle())
+      else:
+        r = app_datastore.get_table( table_name, ENTITY_TABLE_SCHEMA)
+      #logger.debug("result: %s" % r)
+
+      #err = r[0]
+      if len(r) > 1:
+        results = r[1:]
+      else:
+        results = []
+
+      # odds are versions
+      versions = results[1::2]
+      # evens are encoded entities
+      results = results[0::2]  
+      #print "RESULTS:",results
+      #print "VERSIONS:",versions
+      if len(versions) != len(results):
+        return(api_base_pb.VoidProto().Encode(),
+               datastore_pb.Error.INTERNAL_ERROR,
+               'The query had a bad number of results.')
+
+      # convert to objects
+      # Unless its marked as deleted
+      # They are currently strings
+      for index, res in enumerate(results):
+        results[index] = entity_pb.EntityProto(res) 
+        results[index] = datastore.Entity._FromPb(results[index]) 
+
+    logger.debug("====results pre filter====")
+    #logger.debug("%s" % results)
+    if query.has_ancestor():
+      ancestor_path = query.ancestor().path().element_list()
+      def is_descendant(entity):
+        path = entity.key()._Key__reference.path().element_list()
+        return path[:len(ancestor_path)] == ancestor_path
+      results = filter(is_descendant, results)
+ 
+    operators = {datastore_pb.Query_Filter.LESS_THAN:             '<',
+                 datastore_pb.Query_Filter.LESS_THAN_OR_EQUAL:    '<=',
+                 datastore_pb.Query_Filter.GREATER_THAN:          '>',
+                 datastore_pb.Query_Filter.GREATER_THAN_OR_EQUAL: '>=',
+                 datastore_pb.Query_Filter.EQUAL:                 '==',
+                 }
+ 
+    for filt in query.filter_list():
+      assert filt.op() != datastore_pb.Query_Filter.IN
+ 
+      prop = filt.property(0).name().decode('utf-8')
+      op = operators[filt.op()]
+
+      def passes(entity):
+        """ Returns True if the entity passes the filter, False otherwise. """
+        entity_vals = entity.get(prop, [])
+        if type(entity_vals) != types.ListType:
+          entity_vals = [entity_vals]
+ 
+        entity_property_list = [datastore_types.ToPropertyPb(prop, value) for value in entity_vals]
+ 
+        for entity_prop in entity_property_list:
+          fixed_entity_val = datastore_types.FromPropertyPb(entity_prop)
+ 
+          for filter_prop in filt.property_list():
+            filter_val = datastore_types.FromPropertyPb(filter_prop)
+            comp = u'%r %s %r' % (fixed_entity_val, op, filter_val)
+            logger.debug('Evaling filter expression "%s"' % comp )
+            if eval(comp):
+              return True
+        return False
+ 
+      results = filter(passes, results)
+ 
+    for order in query.order_list():
+      prop = order.property().decode('utf-8')
+      results = [entity for entity in results if prop in entity]
+ 
+    def order_compare(a, b):
+      """ Return a negative, zero or positive number depending on whether
+      entity a is considered smaller than, equal to, or larger than b,
+      according to the query's orderings. """
+      for o in query.order_list():
+        prop = o.property().decode('utf-8')
+ 
+        a_values = a[prop]
+        if not isinstance(a_values, types.ListType):
+          a_values = [a_values]
+ 
+        b_values = b[prop]
+        if not isinstance(b_values, types.ListType):
+          b_values = [b_values]
+ 
+        cmped = cmp(min(a_values), min(b_values))
+ 
+        if o.direction() == datastore_pb.Query_Order.DESCENDING:
+          cmped = -cmped
+ 
+        if cmped != 0:
+          return cmped
+ 
+      return 0
+ 
+    results.sort(order_compare)
+ 
+    if query.has_limit():
+      results = results[:query.limit()]
+    logger.debug("****results after filtering:****")
+    logger.debug("%s" % results)
+    
+    results = [ent._ToPb() for ent in results]
+    # Pack Results into a clone of QueryResult #
+    clone_qr_pb = datastore_pb.QueryResult()
+    for res in results:
+      clone_qr_pb.add_result()
+      clone_qr_pb.result_[-1] = res
+    
+    clone_qr_pb.clear_cursor()
+    clone_qr_pb.set_more_results( len(results)>0 )
+
+    logger.debug("QUERY_RESULT: %s" % clone_qr_pb)
+    return (clone_qr_pb.Encode(), 0, "")
+
+
+  def begin_transaction_request(self, app_id, appscale_version, http_request_data):
+    transaction_pb = datastore_pb.Transaction()
+    handle = generate_unique_id(app_id, None, None)
+    #print "Begin Trans Handle:",handle
+    transaction_pb.set_handle(handle)
+    app_datastore.setupTransaction(handle)
+    return (transaction_pb.Encode(), 0, "")
+
+  def commit_transaction_request(self, app_id, appscale_version, http_request_data):
+    transaction_pb = datastore_pb.Transaction(http_request_data)
+    handle = transaction_pb.handle() 
+    commitres_pb = datastore_pb.CommitResponse()
+    try:
+      app_datastore.commit(handle)
+    except:
+      return (commitres_pb.Encode(), datastore_pb.Error.PERMISSION_DENIED, "Unable to commit for this transaction")  
+    return (commitres_pb.Encode(), 0, "")
+
+  def rollback_transaction_request(self, app_id, appscale_version, http_request_data):
+    transaction_pb = datastore_pb.Transaction(http_request_data)
+    handle = transaction_pb.handle() 
+    try:
+      app_datastore.rollback(handle)
+    except:
+      return(api_base_pb.VoidProto().Encode(), datastore_pb.Error.PERMISSION_DENIED, "Unable to rollback for this transaction")
+    return (api_base_pb.VoidProto().Encode(), 0, "")
+
+
+  def allocate_ids_request(self, app_id, appscale_version, http_request_data):
+    return (api_base_pb.VoidProto().Encode(),
+            datastore_pb.Error.PERMISSION_DENIED,
+            'Allocation of block ids not implemented.')
+
+
+  # Returns Null on error
+  def getRootKeyFromEntity(self, app_id, entity):
+    key = entity.key()
+    if str(key.__class__) == "google.appengine.datastore.entity_pb.Reference":
+      return getRootKeyFromRef(app_id, key)
+    else:
+      return getRootKeyFromKeyType(app_id, key)
+
+  
+  # For transactions
+  # Verifies all puts are apart of the same root entity
+  def getRootKeyFromTransPut(self, app_id, putreq_pb):
+    ent_list = []
+    if putreq_pb.entity_size() > 0:
+      ent_list = putreq_pb.entity_list()
+    first_ent = ent_list[0]
+    expected_root = self.getRootKeyFromEntity(app_id, first_ent)
+    # It is possible that all roots are None
+    # because it is a root that has not gotten a uid
+
+    for e in ent_list:
+      root = self.getRootKeyFromEntity(app_id, e) 
+      if root != expected_root:
+        errcode = datastore_pb.Error.BAD_REQUEST
+        errdetail = "All puts must be a part of the same group"
+        return (None, errcode, errdetail)
+
+    return (expected_root, 0, "")
+
+
+  # For transactions
+  # Verifies all puts are apart of the same root entity
+  def getRootKeyFromTransReq(self, app_id, req_pb):
+    if req_pb.key_size() <= 0:
+      errcode = datastore_pb.error.bad_request
+      errdetail = "Bad key listing"
+      return (None, errcode, errdetail)
+
+    key_list = req_pb.key_list()
+    first_key = key_list[0]
+
+    expected_root = getRootKeyFromRef(app_id, first_key)
+    # It is possible that all roots are None
+    # because it is a root that has not gotten a uid
+
+    for k in key_list:
+      root = getRootKeyFromRef(app_id, k) 
+      if root != expected_root:
+        errcode = datastore_pb.error.bad_request
+        errdetail = "all transaction gets must be a part of the same group"
+        return (None, errcode, errdetail)
+
+    return (expected_root, 0, "")
+
+  def getRootKeyFromTransGet(self, app_id, get_pb):
+    return self.getRootKeyFromTransReq(app_id, get_pb)
+
+  def getRootKeyFromTransDel(self, app_id, del_pb):
+    return self.getRootKeyFromTransReq(app_id, del_pb)
+
+  def put_request(self, app_id, appscale_version, http_request_data):
+    global app_datastore
+    global keySecret
+    global tableHashTable
+
+    field_name_list = []
+    field_value_list = []
+
+    start_time = time.time() 
+    putreq_pb = datastore_pb.PutRequest(http_request_data)
+    logger.debug("RECEIVED PUT_REQUEST %s" % putreq_pb)
+    putresp_pb = datastore_pb.PutResponse( )
+    txn = None
+    root_key = None
+    # Must assign an id if a put is being done in a transaction
+    # and it does not have an id and it is a root
+    for e in putreq_pb.entity_list():
+      # Only dealing with root puts
+      if e.key().path().element_size() == 1:
+        root_path = e.key().path().mutable_element(0)
+        #print "has id:",root_path.has_id(), "has name:",root_path.has_name()
+        if root_path.id() == 0 and not root_path.has_name():
+          #new_key = root_key + "/" + last_path.type()
+          uid = generate_unique_id(app_id, None, None)
+          #print "Assigned uid to new root key:",str(uid)
+          if uid <= 0:
+            return (putresp_pb.Encode(), 
+                    datastore_pb.Error.INTERNAL_ERROR,
+                    'Unable to assign a unique id')
+          root_path.set_id(uid)
+
+    # Gather data from Put Request #
+    #print "Entity list for put:"
+    #print putreq_pb.entity_list()
+    for e in putreq_pb.entity_list():
+
+      for prop in e.property_list() + e.raw_property_list():
+        if prop.value().has_uservalue():
+          obuid = md5.new(prop.value().uservalue().email().lower()).digest()
+          obuid = '1' + ''.join(['%02d' % ord(x) for x in obuid])[:20]
+          prop.mutable_value().mutable_uservalue().set_obfuscated_gaiaid(
+              obuid)
+
+      #################################
+      # Key Assignment for new entities
+      #################################  
+      e.mutable_key().set_app(app_id)
+
+      root_type = e.key().path().element(0).type()
+      if root_type[-2:] == "__":
+        return(putresp_pb.Encode(), 
+               datastore_pb.Error.PERMISSION_DENIED, 
+               "Illegal type name contains reserved delimiters \"__\"")
+
+      last_path = e.key().path().element_list()[-1]
+      uid = last_path.id() 
+      kind = last_path.type()
+      # this object has no assigned id thus far
+      if last_path.id() == 0 and not last_path.has_name():
+        if e.key().path().element_size() == 1:
+          root_key = None
+        if root_key:
+          child_key = root_key + "/" + last_path.type()
+        else:
+          child_key = None
+        # if the root is None or the child is None, 
+        # then the global counter is used
+        # gen unique id only wants to know if a child exist
+        uid = generate_unique_id(app_id, root_key, child_key)
+        if uid <= 0: 
+          return(putresp_pb.Encode(), 
+                 datastore_pb.Error.INTERNAL_ERROR, 
+                 "Unable to assign id to entity")
+        last_path.set_id(uid)  
+        # It may be its own parent
+        group = e.mutable_entity_group()
+        root = e.key().path().element(0)
+        group.add_element().CopyFrom(root)
+      if last_path.has_name():
+        uid = last_path.name()
+        # It may be its own parent
+        group = e.mutable_entity_group()
+        if group.element_size() == 0:
+          root = e.key().path().element(0)
+          group.add_element().CopyFrom(root)
+     
+      #######################################
+      # Done with key assignment
+      # Notify Soap Server of any new tables
+      #######################################
+      #print "Putting of type:",kind,"with uid of",str(uid)
+      # insert key 
+      table_name = getTableName(app_id, kind, appscale_version)
+      #print "Put Using table name:",table_name
+      # Notify Users/Apps table if a new class is being added 
+      if table_name not in tableHashTable:
+        # This is the first time this pbserver has seen this table
+        # Notify the User/Apps server via soap call
+        # This function is reentrant
+        # If the class was deleted, and added a second time there is no 
+        # notifying the users/app server of its creation
+        if tableServer.add_class(app_id, kind, keySecret) == "true":
+          tableHashTable[table_name] = 1
+        
+      # Store One Entity #
+      logger.debug("put: %s___%s___%s with id: %s" % (app_id, 
+                                                      kind, 
+                                                      appscale_version, 
+                                                      str(uid)))
+
+      row_key = getRowKey(app_id, e.key().path().element_list())
+      inter_time = time.time() 
+      logger.debug("Time spent in put before datastore call: " + str(inter_time - start_time))
+
+            
+      field_name_list = ENTITY_TABLE_SCHEMA
+      field_value_list =  [e.Encode(), NONEXISTANT_TRANSACTION]
+      if putreq_pb.has_transaction():
+        txn = putreq_pb.transaction()
+        err, res = app_datastore.put_entity( table_name,
+                                           row_key,
+                                           field_name_list,
+                                           field_value_list,
+                                           txn.handle())
+      else:
+        err, res = app_datastore.put_entity( table_name, 
+                                           row_key, 
+                                           field_name_list, 
+                                           field_value_list)
+
+      if err not in ERROR_CODES:
+        #_trans_set.purge(txn)
+        return (putresp_pb.Encode(),
+                datastore_pb.Error.INTERNAL_ERROR,
+                err)
+      
+      putresp_pb.key_list().append(e.key())
+
+      inter_time = time.time()
+      logger.debug("Time spent in put after datastore call: " + str(inter_time - start_time))
+    logger.debug( "PUT_RESPONSE:%s" % putresp_pb)
+    return (putresp_pb.Encode(), 0, "")
+
+
+  def get_request(self, app_id, appscale_version, http_request_data):
+    global app_datastore
+    getreq_pb = datastore_pb.GetRequest(http_request_data)
+    logger.debug("GET_REQUEST: %s" % getreq_pb)
+    getresp_pb = datastore_pb.GetResponse()
+
+           
+    for key in getreq_pb.key_list():
+      key.set_app(app_id)
+      last_path = key.path().element_list()[-1]
+
+      if last_path.has_id():
+        entity_id = last_path.id()
+
+      if last_path.has_name():
+        entity_id = last_path.name()
+
+      if last_path.has_type():
+        kind = last_path.type()
+      logger.debug("get: %s___%s___%s %s" % (app_id, kind, appscale_version, str(entity_id)))
+      table_name = getTableName(app_id, kind, appscale_version)
+      row_key = getRowKey(app_id,key.path().element_list())
+      #print "Get row key:",row_key
+      if getreq_pb.has_transaction():
+        txn = getreq_pb.transaction()
+        r = app_datastore.get_entity( table_name, row_key, ENTITY_TABLE_SCHEMA, txn.handle())
+      else:
+        r = app_datastore.get_entity( table_name, row_key, ENTITY_TABLE_SCHEMA )
+      err = r[0]
+      if err not in ERROR_CODES or len(r) != 3: 
+        r = ["",None,NONEXISTANT_TRANSACTION]
+        print err
+      entity = r[1]
+      prev_version = long(r[2])
+            
+      group = getresp_pb.add_entity()
+      if entity:
+        e_pb = entity_pb.EntityProto( entity )
+        group.mutable_entity().CopyFrom(e_pb)
+        
+    # Send Response #
+    #print getresp_pb
+    logger.debug("GET_RESPONSE: %s" % getresp_pb)
+    return (getresp_pb.Encode(), 0, "")
+
+  """ Deletes are just PUTs using a sentinal value of DELETED
+      All deleted keys are DELETED/entity_group. This is for 
+      rollback to know which entity group a possible failed
+      transaction belongs to.
+  """ 
+  def delete_request(self, app_id, appscale_version, http_request_data):
+    global app_datastore
+    root_key = None
+    txn = None
+    logger.debug("DeleteRequest Received...")
+    delreq_pb = datastore_pb.DeleteRequest( http_request_data )
+    logger.debug("DELETE_REQUEST: %s" % delreq_pb)
+    delresp_pb = api_base_pb.VoidProto() 
+   
+    for key in delreq_pb.key_list():
+      key.set_app(app_id)
+      last_path = key.path().element_list()[-1]
+      if last_path.has_type():
+        kind = last_path.type()
+
+      row_key = getRowKey(app_id, key.path().element_list())
+
+
+      table_name = getTableName(app_id, kind, appscale_version)
+      if delreq_pb.has_transaction():
+        txn = delreq_pb.transaction()
+        res = app_datastore.delete_row( table_name, row_key, txn.handle())
+      else:
+        res = app_datastore.delete_row( table_name, 
+                                           row_key) 
+      err = res[0]
+      logger.debug("Response from DB for delete request %s" % err)
+      if err not in ERROR_CODES: 
+        if DEBUG: print err
+        return (delresp_pb.Encode(),
+                datastore_pb.Error.INTERNAL_ERROR,
+                err + ", Unable to delete row")
+ 
+    return (delresp_pb.Encode(), 0, "")
+
+
+  def optimized_delete_request(self, app_id, appscale_version, http_request_data):
+    pass
+  def run_optimized_query(self, app_id, appscale_version, http_request_data):
+    return 
+  def optimized_put_request(self, app_id, appscale_version, http_request_data):
+    pass
+
+  def void_proto(self, app_id, appscale_version, http_request_data):
+    resp_pb = api_base_pb.VoidProto() 
+    print "Got void"
+    logger.debug("VOID_RESPONSE: %s to void" % resp_pb)
+    return (resp_pb.Encode(), 0, "" )
+  
+  def str_proto(self, app_id, appscale_version, http_request_data):
+    str_pb = api_base_pb.StringProto( http_request_data )
+    composite_pb = datastore_pb.CompositeIndices()
+    print "Got a string proto"
+    print str_pb
+    logger.debug("String proto received: %s"%str_pb)
+    logger.debug("CompositeIndex response to string: %s" % composite_pb)
+    return (composite_pb.Encode(), 0, "" )    
+  
+  def int64_proto(self, app_id, appscale_version, http_request_data):
+    int64_pb = api_base_pb.Integer64Proto( http_request_data ) 
+    resp_pb = api_base_pb.VoidProto()
+    print "Got a int 64"
+    print int64_pb
+    logger.debug("Int64 proto received: %s"%int64_pb)
+    logger.debug("VOID_RESPONSE to int64: %s" % resp_pb)
+    return (resp_pb.Encode(), 0, "")
+ 
+  def compositeindex_proto(self, app_id, appscale_version, http_request_data):
+    compindex_pb = entity_pb.CompositeIndex( http_request_data)
+    resp_pb = api_base_pb.VoidProto()
+    print "Got Composite Index"
+    print compindex_pb
+    logger.debug("CompositeIndex proto recieved: %s"%str(compindex_pb))
+    logger.debug("VOID_RESPONSE to composite index: %s" % resp_pb)
+    return (resp_pb.Encode(), 0, "")
+
+# Returns 0 on success, 1 on failure
+  def create_index_tables(self, app_id):
+    global app_datastore
+    """table_name = "__" + app_id + "__" + "kind"
+    columns = ["reference"]
+    print "Building table: " + table_name
+    returned = app_datastore.create_table( table_name, columns )
+    err,res = returned
+    if err not in ERROR_CODES:
+      logger.debug("%s" % err)
+      return 1
+    """
+    table_name = "__" + app_id + "__" + "single_prop_asc"
+    print "Building table: " + table_name
+    columns = ["reference"]
+    returned = app_datastore.create_table( table_name, columns )
+    err,res = returned
+    if err not in ERROR_CODES:
+      logger.debug("%s" % err)
+      return 1
+
+    table_name = "__" + app_id + "__" + "single_prop_desc"
+    print "Building table: " + table_name
+    returned = app_datastore.create_table( table_name, columns )
+    err,res = returned
+    if err not in ERROR_CODES:
+      logger.debug("%s" % err)
+      return 1
+ 
+    table_name = "__" + app_id + "__" + "composite"
+    print "Building table: " + table_name
+    returned = app_datastore.create_table( table_name, columns )
+    err,res = returned
+    if err not in ERROR_CODES:
+      logger.debug("%s" % err)
+      return 1 
+   
+    return 0 
+
+  ##############
+  # OTHER TYPE #
+  ##############
+  def unknown_request(self, app_id, appscale_version, http_request_data, pb_type):
+    logger.debug("Received Unknown Protocol Buffer %s" % pb_type )
+    print "ERROR: Received Unknown Protocol Buffer <" + pb_type +">.",
+    print "Nothing has been implemented to handle this Protocol Buffer type."
+    print "http request data:"
+    print http_request_data 
+    print "http done"
+    self.void_proto(app_id, appscale_version, http_request_data)
+
+  
+  #########################
+  # POST Request Handling #
+  #########################
+  @tornado.web.asynchronous
+  def post( self ):
+    request = self.request
+    http_request_data = request.body
+    pb_type = request.headers['protocolbuffertype']
+    app_data = request.headers['appdata']
+    app_data  = app_data.split(':')
+
+    if len(app_data) == 5:
+      app_id, user_email, nick_name, auth_domain, appscale_version = app_data
+      os.environ['AUTH_DOMAIN'] = auth_domain
+      os.environ['USER_EMAIL'] = user_email
+      os.environ['USER_NICKNAME'] = nick_name
+      os.environ['APPLICATION_ID'] = app_id 
+    elif len(app_data) == 4:
+      app_id, user_email, nick_name, auth_domain = app_data
+      os.environ['AUTH_DOMAIN'] = auth_domain
+      os.environ['USER_EMAIL'] = user_email
+      os.environ['USER_NICKNAME'] = nick_name
+      os.environ['APPLICATION_ID'] = app_id 
+      appscale_version = "1"
+    elif len(app_data) == 2:
+      app_id, appscale_version = app_data
+      app_id = app_data[0]
+      os.environ['APPLICATION_ID'] = app_id
+    elif len(app_data) == 1:
+      app_id = app_data[0]
+      os.environ['APPLICATION_ID'] = app_id 
+      appscale_version = "1"
+    else:
+      logger.debug("UNABLE TO EXTRACT APPLICATION DATA")
+      return
+
+    # Default HTTP Response Data #
+
+    if pb_type == "Request":
+      self.remote_request(app_id, appscale_version, http_request_data)
+    else:
+      self.unknown_request(app_id, appscale_version, http_request_data, pb_type)
+    self.finish()    
+
+    
+def usage():
+  print "AppScale Server" 
+  print
+  print "Options:"
+  print "\t--certificate=<path-to-ssl-certificate>"
+  print "\t--a=<soap server hostname> "
+  print "\t--key for using keys from the soap server"
+  print "\t--type=<hypertable, hbase, cassandra, mysql, mongodb>"
+  print "\t--secret=<secrete to soap server>"
+  print "\t--blocksize=<key-block-size>"
+  print "\t--optimized_query"
+  print "\t--no_encryption"
+def main(argv):
+  global app_datastore
+  global getKeyFromServer
+  global tableServer
+  global keySecret
+  global logOn
+  global logFilePtr
+  global optimizedQuery
+  global soapServer
+  global ERROR_CODES
+  global VALID_DATASTORES
+  global KEYBLOCKSIZE
+  global zoo_keeper
+  cert_file = CERT_LOCATION
+  key_file = KEY_LOCATION
+  db_type = "hypertable"
+  port = DEFAULT_SSL_PORT
+  isEncrypted = True
+  try:
+    opts, args = getopt.getopt( argv, "c:t:l:s:b:a:k:p:o:n:z:", 
+                               ["certificate=", 
+                                "type=", 
+                                "log=", 
+                                "secret=", 
+                                "blocksize=", 
+                                "soap=", 
+                                "key", 
+                                "port", 
+                                "optimized_query",
+                                "no_encryption",
+                                "zoo_keeper"] )
+  except getopt.GetoptError:
+    usage()
+    sys.exit(1)
+  for opt, arg in opts:
+    if opt in ("-c", "--certificate"):
+      cert_file = arg
+      print "Using cert..."
+    elif opt in ("-k", "--key" ):
+      getKeyFromServer = True
+      print "Using key server..."
+    elif  opt in ("-t", "--type"):
+      db_type = arg
+      print "Datastore type: ",db_type 
+    elif opt in ("-s", "--secret"):
+      keySecret = arg
+      print "Secret set..."
+    elif opt in ("-l", "--log"):
+      logOn = True
+      logFile = arg
+      logFilePtr = open(logFile, "w")
+      logFilePtr.write("# type, app, start, end\n")
+    elif opt in ("-b", "--blocksize"):
+      KEYBLOCKSIZE = arg
+      print "Block size: ",KEYBLOCKSIZE
+    elif opt in ("-a", "--soap"):
+      soapServer = arg
+    elif opt in ("-o", "--optimized_query"):
+      optimizedQuery = True
+    elif opt in ("-p", "--port"):
+      port = int(arg)
+    elif opt in ("-n", "--no_encryption"):
+      isEncrypted = False
+    elif opt in ("-z", "--zoo_keeper"):
+      zoo_keeper_locations = arg      
+
+  app_datastore = appscale_datastore.DatastoreFactory.getDatastore(db_type)
+  ERROR_CODES = appscale_datastore.DatastoreFactory.error_codes()
+  VALID_DATASTORES = appscale_datastore.DatastoreFactory.valid_datastores()
+  if DEBUG: print "ERROR_CODES:"
+  if DEBUG: print ERROR_CODES
+  if DEBUG: print "VALID_DATASTORE:"
+  if DEBUG: print VALID_DATASTORES
+  if db_type in VALID_DATASTORES:
+    logger.debug("Using datastore %s" % db_type)
+  else:
+    print "Unknown datastore "+ db_type
+    exit(1)
+
+  tableServer = SOAPpy.SOAPProxy("https://" + soapServer + ":" + str(keyPort))
+  
+  global keyDictionaryLock 
+  zoo_keeper = zktransaction.ZKTransaction(zoo_keeper_locations)
+
+  keyDictionaryLock = threading.Lock()
+  if port == DEFAULT_SSL_PORT and not isEncrypted:
+    port = DEFAULT_PORT
+  pb_application = tornado.web.Application([
+    (r"/*", MainHandler),
+  ])
+  server = tornado.httpserver.HTTPServer(pb_application)
+  server.listen(port) 
+  if not db_type == "timesten":
+    # Stop running as root, security purposes #
+    drop_privileges()
+
+  while 1:
+    try:
+      # Start Server #
+      tornado.ioloop.IOLoop.instance().start()
+    except SSL.SSLError:
+      logger.debug("\n\nUnexcepted input for AppScale-Secure-Server")
+    except KeyboardInterrupt:
+      print "Server interrupted by user, terminating..."
+      exit(1)
+
+if __name__ == '__main__':
+  #cProfile.run("main(sys.argv[1:])")
+  main(sys.argv[1:])

=== removed file 'AppDB/appscale_server_no_trans.py'
--- AppDB/appscale_server_no_trans.py	2010-05-11 02:07:26 +0000
+++ AppDB/appscale_server_no_trans.py	1970-01-01 00:00:00 +0000
@@ -1,1117 +0,0 @@
-#!/usr/bin/python
-#
-# Author: 
-# Navraj Chohan ([e-mail])
-# Soo Hwan Park ([e-mail])
-# Sydney Pang ([e-mail])
-# See LICENSE file
-
-import sys
-import socket
-import os 
-import types
-import appscale_datastore
-#import helper_functions
-import SOAPpy
-from dbconstants import *
-import appscale_logger
-import md5 
-import random
-import getopt
-from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
-from SocketServer import ThreadingMixIn
-import threading
-
-from google.appengine.api import api_base_pb
-from google.appengine.api import datastore
-from google.appengine.api import datastore_errors
-from google.appengine.api import datastore_types
-from google.appengine.api import users
-from google.appengine.datastore import datastore_pb
-from google.appengine.datastore import datastore_index
-from google.appengine.runtime import apiproxy_errors
-from google.net.proto import ProtocolBuffer
-from google.appengine.datastore import entity_pb
-from google.appengine.ext.remote_api import remote_api_pb
-from SocketServer import BaseServer
-from M2Crypto import SSL
-from drop_privileges import *
-
-import time
-
-DEBUG = False 
-APP_TABLE = APPS_TABLE
-USER_TABLE = USERS_TABLE
-DEFAULT_USER_LOCATION = ".flatfile_users"
-DEFAULT_APP_LOCATION = ".flatfile_apps"
-HYPERTABLE_XML_TAG = "Name"
-DEFAULT_DATASTORE = "files"
-DEFAULT_SSL_PORT = 443
-DEFAULT_PORT = 4080
-DEFAULT_ENCRYPTION = 1
-CERT_LOCATION = "/etc/appscale/certs/mycert.pem"
-KEY_LOCATION = "/etc/appscale/certs/mykey.pem"
-SECRET_LOCATION = "/etc/appscale/secret.key"
-VALID_DATASTORES = []
-ERROR_CODES = []
-app_datastore = []
-logOn = False
-logFilePtr = ""
-
-getKeyFromServer = False
-soapServer = "localhost"
-tableServer = ""
-keyPort = 4343
-keySecret = ""
-KEYBLOCKSIZE = "50"
-keyDictionaryLock = None
-keyDictionary = {}
-keyStart = 0
-keyEnd = 0
-
-optimizedQuery = False
-ID_KEY_LENGTH = 64
-tableHashTable = {}
-
-local_server_address = ""
-HandlerClass = ""
-ssl_cert_file = ""
-ssl_key_file  = ""
-
-DELETED = "DELETED___"
-""" 
-Deleted keys are DELETED/<row_key>
-"""
-
-""" 
-keys for tables take the format
-appname/Grandparent:<ID>/Parent:<ID>/Child:<ID>
-for the entity table
-"""
-
-
-class ThreadLogger:
-  def __init__(self, log):
-    self.logger_ = log
-    self.log_lock = threading.Lock()
-
-  def debug(self, string):
-    return
-    self.log_lock.acquire()
-    print string
-    self.logger_.info(string)
-    self.log_lock.release()
-
-logger = appscale_logger.getLogger("pb_server")
-
-
-def getTableName(app_id, kind, version):
-  return app_id + "___" + kind + "___" + version
-
-def getRowKey(app_id, ancestor_list):
-  if ancestor_list == None:
-    logger.debug("Generate row key received null ancestor list")
-    return ""
-
-  key = app_id 
-
-  # Note: mysql cannot have \ as the first char in the row key
-  for a in ancestor_list:
-    key += "/" 
-    if a.has_type():
-      key += a.type()
-
-    if a.has_id():
-      zero_padded_id = ("0" * (ID_KEY_LENGTH - len(str(a.id())))) + str(a.id())
-      key += ":" + zero_padded_id
-    elif a.has_name():
-      # append _ if the name is a number, prevents collisions of key names
-      if a.name().isdigit():
-        key += ":__key__" + a.name()
-      else: 
-        key += ":" + a.name()
-  return key
-
-
-def getRootKey(app_id, ancestor_list):
-  key = app_id # mysql cannot have \ as the first char in the row key
-  a = ancestor_list[0]
-  key += "/"
-
-  # append _ if the name is a number, prevents collisions of key names
-  if a.has_type():
-    key += a.type()
-  else:
-    return None
-
-  if a.has_id():
-    zero_padded_id = ("0" * (ID_KEY_LENGTH - len(str(a.id())))) + str(a.id())
-    key += ":" + zero_padded_id
-  elif a.has_name():
-    if a.name().isdigit():
-      key += ":__key__" + a.name()
-    else: 
-      key += ":" + a.name()
-  else:
-    return None
-
-  return key
-
-
-def getRootKeyFromKeyType(app_id, key):
-  ancestor_list = key._Key__reference.path().element_list()
-  return getRootKey(app_id, ancestor_list)
-
-
-def getRowKeyFromKeyType(app_id, key):
-  ancestor_list = key._Key__reference.path().element_list()
-  return getRowKey(app_id, ancestor_list)
-
-  
-def getRootKeyFromRef(app_id, ref):
-  if not ref.has_path():
-    return False
-  path = ref.path()
-  element_list = path.element_list()
-  return  getRootKey(app_id, element_list)
-
-
-# Version must be an int
-def getJournalKey(key, version):
-  key+="/"
-  zero_padded_version = ("0" * (ID_KEY_LENGTH - len(str(version)))) + str(version)
-  key += zero_padded_version
-  return key
-
-
-def getJournalTable(app_id, appscale_version):
-  return JOURNAL_TABLE + "___" + app_id + "___" + str(appscale_version)
-
-def generateIDFromServer(app_id):
-  global keySecret
-  global keyStart
-  global keyEnd
-  global tableServer
-  key = 0
-  if keyStart != keyEnd:
-    if DEBUG: print "fast track key serving"
-    if DEBUG: print "Key Start: " + str(keyStart)
-    if DEBUG: print "Key End: " + str(keyEnd)
-    key = int(keyStart)
-    if DEBUG: print "key returned: " + str(key)
-    keyStart = int(keyStart) + 1
-    return key
-  else:
-    # Retrieve a new set of keys
-    if DEBUG: print "slow track key serving"
-    keyStart = tableServer.get_key_block(app_id, KEYBLOCKSIZE, keySecret)
-    try:
-      keyStart = int(keyStart)
-    except:
-      # value is not a number
-      return -1
-    keyEnd = keyStart + int(KEYBLOCKSIZE)
-    if DEBUG: print "Key Start: " + str(keyStart)
-    if DEBUG: print "Key End: " + str(keyEnd)
-    key = keyStart
-    keyStart = keyStart + 1
-    if DEBUG: print "key returned: " + str(key)
-    return key
-
-
-def rollback_function(app_id, trans_id, root_key, change_set):
-  pass
-
-
-class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
-  """ Handle requests in a new thread """
-
-
-class AppScaleSecureHandler( BaseHTTPRequestHandler ):
-  """
-  Defines what to do when the webserver receives different types of 
-  HTTP requests.
-  """
-  def get_http_err_code( self, message ):
-    print message
-    ret = 599  # 599 is the default code for an unknown error #
-    return ret
-
-  def send_post_http_response( self , http_code , message ):
-    self.send_response( http_code )
-    self.send_header( 'Content-type' , 'text/plain' )
-    self.end_headers()
-    self.wfile.write( message )
-
-  def send_http_err_response( self, err_msg ):
-    ret_http_code = self.get_http_err_code( err_msg )
-    self.send_post_http_response( ret_http_code, err_msg )
-  
-  # remote api request
-  # sends back a response 
-  def remote_request(self, app_id, appscale_version, http_request_data):
-    apirequest = remote_api_pb.Request(http_request_data)
-    apiresponse = remote_api_pb.Response()
-    response = None
-    errcode = 0
-    errdetail = "" 
-    apperror_pb = None 
-
-    if not apirequest.has_method(): 
-      errcode = datastore_pb.Error.BAD_REQUEST
-      errdetail = "Method was not set in request"
-      apirequest.set_method("NOT_FOUND")
-    if not apirequest.has_request():
-      errcode = datastore_pb.Error.BAD_REQUEST
-      errdetail = "Request missing in call"
-      apirequest.set_method("NOT_FOUND")
-      apirequest.clear_request()
-    method = apirequest.method()
-    request_data = apirequest.request()
-    http_request_data = request_data.contents()
-
-    print "REQUEST:",method," AT time",time.time()
-    if method == "Put":
-      response, errcode, errdetail = self.put_request(app_id, 
-                                                 appscale_version, 
-                                                 http_request_data)
-    elif method == "Get":
-      response, errcode, errdetail = self.get_request(app_id, 
-                                                 appscale_version, 
-                                                 http_request_data)
-    elif method == "Delete": 
-      response, errcode, errdetail = self.delete_request(app_id, 
-                                                    appscale_version, 
-                                                    http_request_data)
-    elif method == "RunQuery":
-      response, errcode, errdetail = self.run_query(app_id, 
-                                          appscale_version, 
-                                          http_request_data)
-    elif method == "BeginTransaction":
-      response, errcode, errdetail = self.begin_transaction_request(app_id, 
-                                                      appscale_version, 
-                                                      http_request_data)
-    elif method == "Commit":
-      response, errcode, errdetail = self.commit_transaction_request(app_id, 
-                                                      appscale_version,
-                                                      http_request_data)
-    elif method == "Rollback":
-      response, errcode, errdetail = self.rollback_transaction_request(app_id, 
-                                                        appscale_version,
-                                                        http_request_data)
-    elif method == "AllocateIds":
-      response, errcode, errdetail = self.allocate_ids_request(app_id, 
-                                                appscale_version,
-                                                http_request_data)
-    elif method == "CreateIndex":
-      errcode = datastore_pb.Error.PERMISSION_DENIED
-      errdetail = "Create Index is not implemented" 
-      logger.debug(errdetail)
-      """
-      response, errcode, errdetail = self.create_index_request(app_id, 
-                                                appscale_version,
-                                                http_request_data)
-      """
-    elif method == "GetIndices":
-      errcode = datastore_pb.Error.PERMISSION_DENIED 
-      errdetail = "GetIndices is not implemented" 
-      logger.debug(errdetail)
-      """
-      response, errcode, errdetail = self.get_indices_request(app_id, 
-                                               appscale_version,
-                                               http_request_data)
-      """
-    elif method == "UpdateIndex":
-      errcode = datastore_pb.Error.PERMISSION_DENIED 
-      errdetail = "UpdateIndex is not implemented" 
-      logger.debug(errdetail)
-      """
-      response, errcode, errdetail = self.update_index_request(app_id, 
-                                                appscale_version,
-                                                http_request_data)
-      """
-    elif method == "DeleteIndex":
-      errcode = datastore_pb.Error.PERMISSION_DENIED 
-      errdetail = "DeleteIndex is not implemented" 
-      logger.debug(errdetail)
-
-      """
-      response, errcode, errdetail = self.delete_index_request(app_id, 
-                                                appscale_version,
-                                                http_request_data)
-      """
-    else:
-      errcode = datastore_pb.Error.BAD_REQUEST 
-      errdetail = "Unknown datastore message" 
-      logger.debug(errdetail)
-    
-      
-    rawmessage = apiresponse.mutable_response()
-    if response:
-      rawmessage.set_contents(response)
-
-    if errcode != 0:
-      apperror_pb = apiresponse.mutable_application_error()
-      apperror_pb.set_code(errcode)
-      apperror_pb.set_detail(errdetail)
-    if errcode != 0:
-      print "REPLY",method," AT TIME",time.time()
-      print "errcode:",errcode
-      print "errdetail:",errdetail
-    self.send_post_http_response( 200 , apiresponse.Encode() )    
-
-
-  def run_query(self, app_id, appscale_version, http_request_data):
-    global app_datastore
-    query = datastore_pb.Query(http_request_data)
-    logger.debug("QUERY:%s" % query)
-    results = []
-                      
-    if not query.has_kind():
-      # Return nothing in case of error #
-      return (api_base_pb.VoidProto().Encode(),
-              datastore_pb.Error.PERMISSION_DENIED,
-              "Kindless queries are not implemented.")
-    else:
-      kind = query.kind()
-      #print "Query kind:",kind
-
-      # Verify validity of the entity name and applicaiton id #
-      # according to the naming sheme for entity tables #
-      #assert kind[-2:] != "__"
-      #assert app_id[-1] != "_"
-
-      # Fetch query from the datastore # 
-      table_name = getTableName(app_id, kind, appscale_version)
-      #print "Query using table name:",table_name
-      r = app_datastore.get_table( table_name, ENTITY_TABLE_SCHEMA)
-      #logger.debug("result: %s" % r)
-
-      #err = r[0]
-      if len(r) > 1:
-        results = r[1:]
-      else:
-        results = []
-
-      # odds are versions
-      versions = results[1::2]
-      # evens are encoded entities
-      results = results[0::2]  
-      #print "RESULTS:",results
-      #print "VERSIONS:",versions
-      if len(versions) != len(results):
-        return(api_base_pb.VoidProto().Encode(),
-               datastore_pb.Error.INTERNAL_ERROR,
-               'The query had a bad number of results.')
-
-      # convert to objects
-      # Unless its marked as deleted
-      # They are currently strings
-      for index, res in enumerate(results):
-        results[index] = entity_pb.EntityProto(res) 
-        results[index] = datastore.Entity._FromPb(results[index]) 
-
-    logger.debug("====results pre filter====")
-    #logger.debug("%s" % results)
-    if query.has_ancestor():
-      ancestor_path = query.ancestor().path().element_list()
-      def is_descendant(entity):
-        path = entity.key()._Key__reference.path().element_list()
-        return path[:len(ancestor_path)] == ancestor_path
-      results = filter(is_descendant, results)
- 
-    operators = {datastore_pb.Query_Filter.LESS_THAN:             '<',
-                 datastore_pb.Query_Filter.LESS_THAN_OR_EQUAL:    '<=',
-                 datastore_pb.Query_Filter.GREATER_THAN:          '>',
-                 datastore_pb.Query_Filter.GREATER_THAN_OR_EQUAL: '>=',
-                 datastore_pb.Query_Filter.EQUAL:                 '==',
-                 }
- 
-    for filt in query.filter_list():
-      assert filt.op() != datastore_pb.Query_Filter.IN
- 
-      prop = filt.property(0).name().decode('utf-8')
-      op = operators[filt.op()]
-
-      def passes(entity):
-        """ Returns True if the entity passes the filter, False otherwise. """
-        entity_vals = entity.get(prop, [])
-        if type(entity_vals) != types.ListType:
-          entity_vals = [entity_vals]
- 
-        entity_property_list = [datastore_types.ToPropertyPb(prop, value) for value in entity_vals]
- 
-        for entity_prop in entity_property_list:
-          fixed_entity_val = datastore_types.FromPropertyPb(entity_prop)
- 
-          for filter_prop in filt.property_list():
-            filter_val = datastore_types.FromPropertyPb(filter_prop)
-            comp = u'%r %s %r' % (fixed_entity_val, op, filter_val)
-            logger.debug('Evaling filter expression "%s"' % comp )
-            if eval(comp):
-              return True
-        return False
- 
-      results = filter(passes, results)
- 
-    for order in query.order_list():
-      prop = order.property().decode('utf-8')
-      results = [entity for entity in results if prop in entity]
- 
-    def order_compare(a, b):
-      """ Return a negative, zero or positive number depending on whether
-      entity a is considered smaller than, equal to, or larger than b,
-      according to the query's orderings. """
-      for o in query.order_list():
-        prop = o.property().decode('utf-8')
- 
-        a_values = a[prop]
-        if not isinstance(a_values, types.ListType):
-          a_values = [a_values]
- 
-        b_values = b[prop]
-        if not isinstance(b_values, types.ListType):
-          b_values = [b_values]
- 
-        cmped = cmp(min(a_values), min(b_values))
- 
-        if o.direction() == datastore_pb.Query_Order.DESCENDING:
-          cmped = -cmped
- 
-        if cmped != 0:
-          return cmped
- 
-      return 0
- 
-    results.sort(order_compare)
- 
-    if query.has_limit():
-      results = results[:query.limit()]
-    logger.debug("****results after filtering:****")
-    logger.debug("%s" % results)
-    
-    results = [ent._ToPb() for ent in results]
-    # Pack Results into a clone of QueryResult #
-    clone_qr_pb = datastore_pb.QueryResult()
-    for res in results:
-      clone_qr_pb.add_result()
-      clone_qr_pb.result_[-1] = res
-    
-    clone_qr_pb.clear_cursor()
-    clone_qr_pb.set_more_results( len(results)>0 )
-
-    logger.debug("QUERY_RESULT: %s" % clone_qr_pb)
-    return (clone_qr_pb.Encode(), 0, "")
-
-
-  def begin_transaction_request(self, app_id, appscale_version, http_request_data):
-    transaction_pb = datastore_pb.Transaction()
-    handle = random.randint(1,1000000)
-    print "Begin Trans Handle:",handle
-    transaction_pb.set_handle(handle)
-    return (transaction_pb.Encode(), 0, "")
-
-  def commit_transaction_request(self, app_id, appscale_version, http_request_data):
-    commitres_pb = datastore_pb.CommitResponse()
-    return (commitres_pb.Encode(), 0, "")
-    
-
-  def rollback_transaction_request(self, app_id, appscale_version, http_request_data):
-    return (api_base_pb.VoidProto().Encode(), 0, "")
-
-
-  def allocate_ids_request(self, app_id, appscale_version, http_request_data):
-    return (api_base_pb.VoidProto().Encode(),
-            datastore_pb.Error.PERMISSION_DENIED,
-            'Allocation of block ids not implemented.')
-
-
-  # Returns Null on error
-  def getRootKeyFromEntity(self, app_id, entity):
-    key = entity.key()
-    if str(key.__class__) == "google.appengine.datastore.entity_pb.Reference":
-      return getRootKeyFromRef(app_id, key)
-    else:
-      return getRootKeyFromKeyType(app_id, key)
-
-  
-  # For transactions
-  # Verifies all puts are apart of the same root entity
-  def getRootKeyFromTransPut(self, app_id, putreq_pb):
-    ent_list = []
-    if putreq_pb.entity_size() > 0:
-      ent_list = putreq_pb.entity_list()
-    first_ent = ent_list[0]
-    expected_root = self.getRootKeyFromEntity(app_id, first_ent)
-    # It is possible that all roots are None
-    # because it is a root that has not gotten a uid
-
-    for e in ent_list:
-      root = self.getRootKeyFromEntity(app_id, e) 
-      if root != expected_root:
-        errcode = datastore_pb.Error.BAD_REQUEST
-        errdetail = "All puts must be a part of the same group"
-        return (None, errcode, errdetail)
-
-    return (expected_root, 0, "")
-
-
-  # For transactions
-  # Verifies all puts are apart of the same root entity
-  def getRootKeyFromTransReq(self, app_id, req_pb):
-    if req_pb.key_size() <= 0:
-      errcode = datastore_pb.error.bad_request
-      errdetail = "Bad key listing"
-      return (None, errcode, errdetail)
-
-    key_list = req_pb.key_list()
-    first_key = key_list[0]
-
-    expected_root = getRootKeyFromRef(app_id, first_key)
-    # It is possible that all roots are None
-    # because it is a root that has not gotten a uid
-
-    for k in key_list:
-      root = getRootKeyFromRef(app_id, k) 
-      if root != expected_root:
-        errcode = datastore_pb.error.bad_request
-        errdetail = "all transaction gets must be a part of the same group"
-        return (None, errcode, errdetail)
-
-    return (expected_root, 0, "")
-
-  def getRootKeyFromTransGet(self, app_id, get_pb):
-    return self.getRootKeyFromTransReq(app_id, get_pb)
-
-  def getRootKeyFromTransDel(self, app_id, del_pb):
-    return self.getRootKeyFromTransReq(app_id, del_pb)
-
-  def put_request(self, app_id, appscale_version, http_request_data):
-    global app_datastore
-    global keySecret
-    global tableHashTable
-
-    field_name_list = []
-    field_value_list = []
-
-    start_time = time.time() 
-    putreq_pb = datastore_pb.PutRequest(http_request_data)
-    logger.debug("RECEIVED PUT_REQUEST %s" % putreq_pb)
-    putresp_pb = datastore_pb.PutResponse( )
-    txn = None
-    root_key = None
-    # Must assign an id if a put is being done in a transaction
-    # and it does not have an id and it is a root
-    for e in putreq_pb.entity_list():
-      # Only dealing with root puts
-      if e.key().path().element_size() == 1:
-        root_path = e.key().path().mutable_element(0)
-        #print "has id:",root_path.has_id(), "has name:",root_path.has_name()
-        if root_path.id() == 0 and not root_path.has_name():
-          #new_key = root_key + "/" + last_path.type()
-          uid = generateIDFromServer(app_id)
-          #print "Assigned uid to new root key:",str(uid)
-          if uid <= 0:
-            return (putresp_pb.Encode(), 
-                    datastore_pb.Error.INTERNAL_ERROR,
-                    'Unable to assign a unique id')
-          root_path.set_id(uid)
-
-    # Gather data from Put Request #
-    #print "Entity list for put:"
-    #print putreq_pb.entity_list()
-    for e in putreq_pb.entity_list():
-
-      for prop in e.property_list() + e.raw_property_list():
-        if prop.value().has_uservalue():
-          obuid = md5.new(prop.value().uservalue().email().lower()).digest()
-          obuid = '1' + ''.join(['%02d' % ord(x) for x in obuid])[:20]
-          prop.mutable_value().mutable_uservalue().set_obfuscated_gaiaid(
-              obuid)
-
-      #################################
-      # Key Assignment for new entities
-      #################################  
-      e.mutable_key().set_app(app_id)
-
-      root_type = e.key().path().element(0).type()
-      if root_type[-2:] == "__":
-        return(putresp_pb.Encode(), 
-               datastore_pb.Error.PERMISSION_DENIED, 
-               "Illegal type name contains reserved delimiters \"__\"")
-
-      last_path = e.key().path().element_list()[-1]
-      uid = last_path.id() 
-      kind = last_path.type()
-      # this object has no assigned id thus far
-      if last_path.id() == 0 and not last_path.has_name():
-        if e.key().path().element_size() == 1:
-          root_key = None
-        if root_key:
-          child_key = root_key + "/" + last_path.type()
-        else:
-          child_key = None
-        # if the root is None or the child is None, 
-        # then the global counter is used
-        # gen unique id only wants to know if a child exist
-        uid = generateIDFromServer(app_id)
-        if uid <= 0: 
-          return(putresp_pb.Encode(), 
-                 datastore_pb.Error.INTERNAL_ERROR, 
-                 "Unable to assign id to entity")
-        last_path.set_id(uid)  
-        # It may be its own parent
-        group = e.mutable_entity_group()
-        root = e.key().path().element(0)
-        group.add_element().CopyFrom(root)
-      if last_path.has_name():
-        uid = last_path.name()
-        # It may be its own parent
-        group = e.mutable_entity_group()
-        if group.element_size() == 0:
-          root = e.key().path().element(0)
-          group.add_element().CopyFrom(root)
-     
-      #######################################
-      # Done with key assignment
-      # Notify Soap Server of any new tables
-      #######################################
-      #print "Putting of type:",kind,"with uid of",str(uid)
-      # insert key 
-      table_name = getTableName(app_id, kind, appscale_version)
-      #print "Put Using table name:",table_name
-      # Notify Users/Apps table if a new class is being added 
-      if table_name not in tableHashTable:
-        # This is the first time this pbserver has seen this table
-        # Notify the User/Apps server via soap call
-        # This function is reentrant
-        # If the class was deleted, and added a second time there is no 
-        # notifying the users/app server of its creation
-        if tableServer.add_class(app_id, kind, keySecret) == "true":
-          tableHashTable[table_name] = 1
-        
-      # Store One Entity #
-      logger.debug("put: %s___%s___%s with id: %s" % (app_id, 
-                                                      kind, 
-                                                      appscale_version, 
-                                                      str(uid)))
-
-      row_key = getRowKey(app_id, e.key().path().element_list())
-      inter_time = time.time() 
-      logger.debug("Time spent in put before datastore call: " + str(inter_time - start_time))
-
-            
-      field_name_list = ENTITY_TABLE_SCHEMA
-      field_value_list =  [e.Encode(), NONEXISTANT_TRANSACTION]
-      err, res = app_datastore.put_entity( table_name, 
-                                           row_key, 
-                                           field_name_list, 
-                                           field_value_list)
-
-      if err not in ERROR_CODES:
-        #_trans_set.purge(txn)
-        return (putresp_pb.Encode(),
-                datastore_pb.Error.INTERNAL_ERROR,
-                err)
-      
-      putresp_pb.key_list().append(e.key())
-
-      inter_time = time.time()
-      logger.debug("Time spent in put after datastore call: " + str(inter_time - start_time))
-    logger.debug( "PUT_RESPONSE:%s" % putresp_pb)
-    return (putresp_pb.Encode(), 0, "")
-
-
-  def get_request(self, app_id, appscale_version, http_request_data):
-    global app_datastore
-    getreq_pb = datastore_pb.GetRequest(http_request_data)
-    logger.debug("GET_REQUEST: %s" % getreq_pb)
-    getresp_pb = datastore_pb.GetResponse()
-
-           
-    for key in getreq_pb.key_list():
-      key.set_app(app_id)
-      last_path = key.path().element_list()[-1]
-
-      if last_path.has_id():
-        entity_id = last_path.id()
-
-      if last_path.has_name():
-        entity_id = last_path.name()
-
-      if last_path.has_type():
-        kind = last_path.type()
-      logger.debug("get: %s___%s___%s %s" % (app_id, kind, appscale_version, str(entity_id)))
-      table_name = getTableName(app_id, kind, appscale_version)
-      row_key = getRowKey(app_id,key.path().element_list())
-      print "Get row key:",row_key
-      r = app_datastore.get_entity( table_name, row_key, ENTITY_TABLE_SCHEMA )
-      err = r[0]
-      if err not in ERROR_CODES or len(r) != 3: 
-        r = ["",None,NONEXISTANT_TRANSACTION]
-        print err
-      entity = r[1]
-      prev_version = long(r[2])
-            
-      group = getresp_pb.add_entity()
-      if entity:
-        e_pb = entity_pb.EntityProto( entity )
-        group.mutable_entity().CopyFrom(e_pb)
-        
-    # Send Response #
-    print getresp_pb
-    logger.debug("GET_RESPONSE: %s" % getresp_pb)
-    return (getresp_pb.Encode(), 0, "")
-
-  """ Deletes are just PUTs using a sentinal value of DELETED
-      All deleted keys are DELETED/entity_group. This is for 
-      rollback to know which entity group a possible failed
-      transaction belongs to.
-  """ 
-  def delete_request(self, app_id, appscale_version, http_request_data):
-    global app_datastore
-    root_key = None
-    txn = None
-    logger.debug("DeleteRequest Received...")
-    delreq_pb = datastore_pb.DeleteRequest( http_request_data )
-    logger.debug("DELETE_REQUEST: %s" % delreq_pb)
-    delresp_pb = api_base_pb.VoidProto() 
-   
-    for key in delreq_pb.key_list():
-      key.set_app(app_id)
-      last_path = key.path().element_list()[-1]
-      if last_path.has_type():
-        kind = last_path.type()
-
-      row_key = getRowKey(app_id, key.path().element_list())
-
-
-      table_name = getTableName(app_id, kind, appscale_version)
-      res = app_datastore.delete_row( table_name, 
-                                           row_key) 
-      err = res[0]
-      logger.debug("Response from DB for delete request %s" % err)
-      if err not in ERROR_CODES: 
-        if DEBUG: print err
-        return (delresp_pb.Encode(),
-                datastore_pb.Error.INTERNAL_ERROR,
-                err + ", Unable to write to journal")
- 
-    return (delresp_pb.Encode(), 0, "")
-
-
-  def optimized_delete_request(self, app_id, appscale_version, http_request_data):
-    pass
-  def run_optimized_query(self, app_id, appscale_version, http_request_data):
-    return 
-  def optimized_put_request(self, app_id, appscale_version, http_request_data):
-    pass
-
-  def void_proto(self, app_id, appscale_version, http_request_data):
-    resp_pb = api_base_pb.VoidProto() 
-    print "Got void"
-    logger.debug("VOID_RESPONSE: %s to void" % resp_pb)
-    return (resp_pb.Encode(), 0, "" )
-  
-  def str_proto(self, app_id, appscale_version, http_request_data):
-    str_pb = api_base_pb.StringProto( http_request_data )
-    composite_pb = datastore_pb.CompositeIndices()
-    print "Got a string proto"
-    print str_pb
-    logger.debug("String proto received: %s"%str_pb)
-    logger.debug("CompositeIndex response to string: %s" % composite_pb)
-    return (composite_pb.Encode(), 0, "" )    
-  
-  def int64_proto(self, app_id, appscale_version, http_request_data):
-    int64_pb = api_base_pb.Integer64Proto( http_request_data ) 
-    resp_pb = api_base_pb.VoidProto()
-    print "Got a int 64"
-    print int64_pb
-    logger.debug("Int64 proto received: %s"%int64_pb)
-    logger.debug("VOID_RESPONSE to int64: %s" % resp_pb)
-    return (resp_pb.Encode(), 0, "")
- 
-  def compositeindex_proto(self, app_id, appscale_version, http_request_data):
-    compindex_pb = entity_pb.CompositeIndex( http_request_data)
-    resp_pb = api_base_pb.VoidProto()
-    print "Got Composite Index"
-    print compindex_pb
-    logger.debug("CompositeIndex proto recieved: %s"%str(compindex_pb))
-    logger.debug("VOID_RESPONSE to composite index: %s" % resp_pb)
-    return (resp_pb.Encode(), 0, "")
-
-# Returns 0 on success, 1 on failure
-  def create_index_tables(self, app_id):
-    global app_datastore
-    """table_name = "__" + app_id + "__" + "kind"
-    columns = ["reference"]
-    print "Building table: " + table_name
-    returned = app_datastore.create_table( table_name, columns )
-    err,res = returned
-    if err not in ERROR_CODES:
-      logger.debug("%s" % err)
-      return 1
-    """
-    table_name = "__" + app_id + "__" + "single_prop_asc"
-    print "Building table: " + table_name
-    columns = ["reference"]
-    returned = app_datastore.create_table( table_name, columns )
-    err,res = returned
-    if err not in ERROR_CODES:
-      logger.debug("%s" % err)
-      return 1
-
-    table_name = "__" + app_id + "__" + "single_prop_desc"
-    print "Building table: " + table_name
-    returned = app_datastore.create_table( table_name, columns )
-    err,res = returned
-    if err not in ERROR_CODES:
-      logger.debug("%s" % err)
-      return 1
- 
-    table_name = "__" + app_id + "__" + "composite"
-    print "Building table: " + table_name
-    returned = app_datastore.create_table( table_name, columns )
-    err,res = returned
-    if err not in ERROR_CODES:
-      logger.debug("%s" % err)
-      return 1 
-   
-    return 0 
-
-  ##############
-  # OTHER TYPE #
-  ##############
-  def unknown_request(self, app_id, appscale_version, http_request_data, pb_type):
-    logger.debug("Received Unknown Protocol Buffer %s" % pb_type )
-    print "ERROR: Received Unknown Protocol Buffer <" + pb_type +">.",
-    print "Nothing has been implemented to handle this Protocol Buffer type."
-    print "http request data:"
-    print http_request_data 
-    print "http done"
-    self.void_proto(app_id, appscale_version, http_request_data)
-
-  ########################
-  # GET Request Handling #
-  ########################
-  def do_GET( self ):
-    self.send_error( 404 , 'File Not Found: %s' % self.path )
-  
-  #########################
-  # POST Request Handling #
-  #########################
-  def do_POST( self ):
-    start_time = time.time() 
-    http_request_data = self.rfile.read(int(self.headers.getheader('content-length')))
-    inter_time = time.time()
-    logger.debug("Timing for pre pre env setup:" + " " + 
-                 str(start_time) + " " + str(inter_time) + 
-                 " total time: " + str(inter_time - start_time) + "\n")
-    print "intertime - starttime:",(str(inter_time - start_time))
-    pb_type = self.headers.getheader( 'protocolbuffertype' )  
-    app_data = self.headers.getheader('appdata')
-    app_data  = app_data.split(':')
-    logger.debug("POST len: %d" % len(app_data))
-    inter_time = time.time()
-    logger.debug("Timing for pre env setup:" + " " + 
-                 str(start_time) + " " + str(inter_time) + 
-                 " total time: " + str(inter_time - start_time) + "\n") 
-
-    if len(app_data) == 5:
-      app_id, user_email, nick_name, auth_domain, appscale_version = app_data
-      os.environ['AUTH_DOMAIN'] = auth_domain
-      os.environ['USER_EMAIL'] = user_email
-      os.environ['USER_NICKNAME'] = nick_name
-      os.environ['APPLICATION_ID'] = app_id 
-    elif len(app_data) == 4:
-      app_id, user_email, nick_name, auth_domain = app_data
-      os.environ['AUTH_DOMAIN'] = auth_domain
-      os.environ['USER_EMAIL'] = user_email
-      os.environ['USER_NICKNAME'] = nick_name
-      os.environ['APPLICATION_ID'] = app_id 
-      appscale_version = "1"
-    elif len(app_data) == 2:
-      app_id, appscale_version = app_data
-      app_id = app_data[0]
-      os.environ['APPLICATION_ID'] = app_id
-    elif len(app_data) == 1:
-      app_id = app_data[0]
-      os.environ['APPLICATION_ID'] = app_id 
-      appscale_version = "1"
-    else:
-      logger.debug("UNABLE TO EXTRACT APPLICATION DATA")
-      return
-
-    # Default HTTP Response Data #
-    logger.debug("For app id: " + app_id)
-    logger.debug("For app version: " + appscale_version)
-    inter_time = time.time()
-    logger.debug("Timing for env setup:" + pb_type + " " + 
-                 app_id + " " + str(start_time) + " " + 
-                 str(inter_time) + " total time: " + str(inter_time - start_time) + "\n") 
-
-    if pb_type == "Request":
-      self.remote_request(app_id, appscale_version, http_request_data)
-    else:
-      self.unknown_request(app_id, appscale_version, http_request_data, pb_type)
-    
-    stop_time = time.time()
-
-    #if logOn == True:
-    #logFilePtr.write(pb_type + " " + app_id + " " + 
-    #str(start_time) + " " + str(stop_time) + " total time: " + 
-    #str(stop_time - start_time) + "\n") 
-      
-    logger.debug(pb_type + " " + app_id + " " + str(start_time) + " " + 
-                 str(stop_time) + " total time: " + str(stop_time - start_time) + "\n") 
-        
-class AppScaleUnSecureServerThreaded( ThreadingMixIn, HTTPServer):
-  pass
-
-class AppScaleSecureServerThreaded( ThreadingMixIn, HTTPServer ):
-  def __init__( self):
-    global local_server_address
-    global HandlerClass
-    global ssl_cert_file
-    global ssl_key_file  
-    BaseServer.__init__( self, local_server_address, HandlerClass )
-    ctx = SSL.Context()
-    ctx.load_cert( ssl_cert_file, ssl_key_file )
-    self.socket = SSL.Connection( ctx )
-    self.server_bind()
-    self.server_activate()
-    
-def usage():
-  print "AppScale Server" 
-  print
-  print "Options:"
-  print "\t--certificate=<path-to-ssl-certificate>"
-  print "\t--a=<soap server hostname> "
-  print "\t--key for using keys from the soap server"
-  print "\t--type=<hypertable, hbase, cassandra, mysql, mongodb>"
-  print "\t--secret=<secrete to soap server>"
-  print "\t--blocksize=<key-block-size>"
-  print "\t--optimized_query"
-  print "\t--no_encryption"
-def main(argv):
-  global app_datastore
-  global getKeyFromServer
-  global tableServer
-  global keySecret
-  global logOn
-  global logFilePtr
-  global optimizedQuery
-  global soapServer
-  global ERROR_CODES
-  global VALID_DATASTORES
-  global KEYBLOCKSIZE
-  cert_file = CERT_LOCATION
-  key_file = KEY_LOCATION
-  db_type = "hypertable"
-  port = DEFAULT_SSL_PORT
-  isEncrypted = True
-  try:
-    opts, args = getopt.getopt( argv, "c:t:l:s:b:a:k:p:o:n:z", 
-                               ["certificate=", 
-                                "type=", 
-                                "log=", 
-                                "secret=", 
-                                "blocksize=", 
-                                "soap=", 
-                                "key", 
-                                "port", 
-                                "optimized_query",
-                                "no_encryption",
-                                "zoo_keeper"] )
-  except getopt.GetoptError:
-    usage()
-    sys.exit(1)
-  for opt, arg in opts:
-    if opt in ("-c", "--certificate"):
-      cert_file = arg
-      print "Using cert..."
-    elif opt in ("-k", "--key" ):
-      getKeyFromServer = True
-      print "Using key server..."
-    elif  opt in ("-t", "--type"):
-      db_type = arg
-      print "Datastore type: ",db_type 
-    elif opt in ("-s", "--secret"):
-      keySecret = arg
-      print "Secret set..."
-    elif opt in ("-l", "--log"):
-      logOn = True
-      logFile = arg
-      logFilePtr = open(logFile, "w")
-      logFilePtr.write("# type, app, start, end\n")
-    elif opt in ("-b", "--blocksize"):
-      KEYBLOCKSIZE = arg
-      print "Block size: ",KEYBLOCKSIZE
-    elif opt in ("-a", "--soap"):
-      soapServer = arg
-    elif opt in ("-o", "--optimized_query"):
-      optimizedQuery = True
-    elif opt in ("-p", "--port"):
-      port = int(arg)
-    elif opt in ("-n", "--no_encryption"):
-      isEncrypted = False
-    elif opt in ("-z", "--zoo_keeper"):
-      print "This version does not use zoo keeper"
-      exit(1)
-
-  app_datastore = appscale_datastore.DatastoreFactory.getDatastore(db_type)
-  ERROR_CODES = appscale_datastore.DatastoreFactory.error_codes()
-  VALID_DATASTORES = appscale_datastore.DatastoreFactory.valid_datastores()
-  if DEBUG: print "ERROR_CODES:"
-  if DEBUG: print ERROR_CODES
-  if DEBUG: print "VALID_DATASTORE:"
-  if DEBUG: print VALID_DATASTORES
-  if db_type in VALID_DATASTORES:
-    logger.debug("Using datastore %s" % db_type)
-  else:
-    print "Unknown datastore "+ db_type
-    exit(1)
-
-  tableServer = SOAPpy.SOAPProxy("https://" + soapServer + ":" + str(keyPort))
-  
- # # Bind Port #
-  #server = AppScaleSecureServer( ('',DEFAULT_SSL_PORT), 
-  #                              AppScaleSecureHandler, cert_file, key_file )
-  #help(ThreadedHTTPServer)
-  global local_server_address
-  global HandlerClass
-  global ssl_cert_file
-  global ssl_key_file  
-  global keyDictionaryLock 
-
-  keyDictionaryLock = threading.Lock()
-  if port == DEFAULT_SSL_PORT and not isEncrypted:
-    port = DEFAULT_PORT
-  local_server_address = ('',port)
-  HandlerClass = AppScaleSecureHandler
-  ssl_cert_file = cert_file
-  ssl_key_file = key_file 
-  if isEncrypted:
-    server = AppScaleSecureServerThreaded()
-  else:
-    server = AppScaleUnSecureServerThreaded(local_server_address, HandlerClass)  
-  sa = server.socket.getsockname()
-  if not db_type == "timesten":
-    # Stop running as root, security purposes #
-    drop_privileges()
-  logger.debug("\n\nStarting AppScale-Secure-Server on %s:%s" % (sa[0], sa[1]))
-
-  while 1:
-    try:
-      # Start Server #
-      server.serve_forever()
-    except SSL.SSLError:
-      logger.debug("\n\nUnexcepted input for AppScale-Secure-Server on %s:%s" % (sa[0], sa[1]))
-    except KeyboardInterrupt:
-      server.socket.close() 
-      print "Server interrupted by user, terminating..."
-      exit(1)
-
-if __name__ == '__main__':
-  #cProfile.run("main(sys.argv[1:])")
-  main(sys.argv[1:])

=== removed file 'AppDB/as_transaction.py'
--- AppDB/as_transaction.py	2010-05-10 21:08:10 +0000
+++ AppDB/as_transaction.py	1970-01-01 00:00:00 +0000
@@ -1,241 +0,0 @@
-import threading
-import time 
-import sys
-from google.net.proto import ProtocolBuffer
-from google.appengine.datastore import datastore_pb
-from google.appengine.runtime import apiproxy_errors
-GC_PERIOD = 100
-TRANS_TIMEOUT = 60 
-class ASTransaction:
-  def __init__(self, handle, entity_group = None, lease = 0):
-    self.handle = handle
-    self.group = entity_group
-    self.lease = lease
-    if lease == 0:
-      self.lease = time.time() + TRANS_TIMEOUT
-    self.change_set = None
-  
-  
-  def addModifiedKey(self, key):
-    if not self.change_set:
-      self.change_set = set()
-    self.change_set.add(key)
-  
-
-  def getModifiedKeysCopy(self):
-    if self.change_set == None:
-      return None
-    return self.change_set.copy()
-
-
-  def __str__(self):
-    s = "handle: " + str(self.handle) + "\n"
-    s += "group: " + str(self.group) + "\n"
-    s += "lease:" + str(self.lease) + "\n"
-    s += "change set:" + str(self.change_set) 
-    return s
-
-
-  def __def__(self):
-    del self.change_set
-  
-
-
-#Thread safe set
-class ASTransSet:
-  def __init__(self):
-    self._txes = {}
-    self._txes_lock = threading.Lock()
-    self.startGC()
-
-  def startGC(self):
-    self.gcthread = threading.Thread(target = self.__gcRunner)
-    self.gcthread.start()
-
-  def __gcRunner(self):
-    
-    while 1:
-      time.sleep(GC_PERIOD)
-      del_list = []
-      cur_time = time.time()
-      self._txes_lock.acquire()
-      for ii in self._txes:
-        if self._txes[ii].lease <= cur_time:
-          del_list.append(ii)
-      # iterate backwards to make deletes safe
-      del_list.reverse()
-      for ii in del_list:
-        del self._txes[ii]
-      self._txes_lock.release()
-
-
-  # Takes a transaction_pb
-  # Checks to see if the transaction exist and if 
-  # it has timed out
-  def isValid(self, txn):
-    handle = None
-    if not txn.has_handle():
-      return False
-
-    handle = txn.handle()
-    curtime = time.time()
-    self._txes_lock.acquire()
-    if handle not in self._txes:
-      self._txes_lock.release()
-      return False
-    else:
-      if self._txes[handle].lease <= curtime:
-        self._txes_lock.release()
-        return False
-    self._txes_lock.release()
-
-    return True
-
-
-  # Takes a transaction_pb
-  def needsLock(self, txn):
-    handle = txn.handle()
-    self._txes_lock.acquire()
-    txn_copy = self._txes[handle]
-    if txn_copy.group == None:
-      self._txes_lock.release()
-      return True
-    else:
-      self._txes_lock.release()
-      return False
-
-
-  def hasLockExpired(self, txn):
-    cur_time = time.time()
-    handle = txn.handle()
-    self._txes_lock.acquire()
-    txn_copy = self._txes[handle]
-    if txn_copy.lease <= cur_time:
-      print "Cur",str(cur_time),"lease",str(txn_copy.lease)
-      self._txes_lock.release()
-      return True
-    else:
-      self._txes_lock.release()
-      return False
-
-
-  # Takes a transaction_pb
-  def purge(self, txn):
-    if not txn:
-      return
-    handle = txn.handle()
-    self._txes_lock.acquire()
-    if handle in self._txes:
-      del self._txes[handle]
-    self._txes_lock.release()
-
-
-  # Takes a transaction_pb
-  def getGroup(self, txn):
-    handle = txn.handle()
-    group = None
-    self._txes_lock.acquire()
-    if handle in self._txes:
-      group = self._txes[handle].group
-    self._txes_lock.release()
-    return group
-
-  # Takes a transaction_pb
-  def add(self, txn):
-    handle = txn.handle()
-    tx = ASTransaction(handle)
-    self._txes_lock.acquire()
-    if handle in self._txes:
-      self._txes_lock.release()
-      return False
-    self._txes[handle] = tx
-    self._txes_lock.release()
-    return True
-
-
-  def setLease(self, txn, lease):
-    handle = txn.handle()
-    self._txes_lock.acquire()
-    txn_copy = self._txes[handle]
-    txn_copy.lease = lease
-    self._txes[handle] = txn_copy
-    self._txes_lock.release()
-   
-
-  def addChangeSet(self, txn, key):
-    handle = txn.handle()
-    self._txes_lock.acquire()
-    txn_copy = self._txes[handle]
-    txn_copy.addModifiedKey(key)
-    self._txes[handle] = txn_copy
-    self._txes_lock.release()
-
-   
-  def getChangeSet(self, txn):
-    handle = txn.handle()
-    self._txes_lock.acquire()
-    txn_copy = self._txes[handle]
-    change_set = txn_copy.getModifiedKeysCopy()
-    self._txes_lock.release()
-    return change_set
-
-
-  def setGroup(self, txn, group):
-    handle = txn.handle()
-    self._txes_lock.acquire()
-    txn_copy = self._txes[handle]
-    txn_copy.group = group
-    self._txes[handle] = txn_copy
-    self._txes_lock.release()
-
-  def printSet(self):
-    print "============================="
-    for ii in self._txes:
-      print self._txes[ii]
-    print "============================="
-
-
-###################### 
-# Unit testing
-######################
-def main(argv):
-  tran_pb = datastore_pb.Transaction()
-  tran_pb.set_handle(500)
-  tran_set = ASTransSet()
-  tran_set.add(tran_pb)
-  print "Needs the lock without the group set:" + str(tran_set.needsLock(tran_pb))
-  tran_set.setGroup(tran_pb, "my_group") 
-  print "Does not Need lock with the group set:" + str(tran_set.needsLock(tran_pb))
-  tran_set.setLease(tran_pb, time.time() + .02)
-  tran_set.addChangeSet(tran_pb, "first key")
-  tran_set.addChangeSet(tran_pb, "second key")
-  tran_set.printSet()
-  print "Has the lock expired (no)?:" + str(tran_set.hasLockExpired(tran_pb))
-  time.sleep(1)
-  print "Has the lock expired (yes)?:" + str(tran_set.hasLockExpired(tran_pb))
-  print "******************"
-  
-  tran_pb = datastore_pb.Transaction() 
-  tran_pb.set_handle(600)
-  tran_set.add(tran_pb)
-  print "Needs the lock without the group set:" + str(tran_set.needsLock(tran_pb))
-  tran_set.setGroup(tran_pb, "my_group")
-  print "Does not Need lock with the group set:" + str(tran_set.needsLock(tran_pb))
-  print "Group is: " + str(tran_set.getGroup(tran_pb))
-  tran_set.printSet()
-  print "******************"
-  print "Removing 600"
-  print "******************"
-  
-  tran_set.purge(tran_pb)
-  tran_set.printSet()
-  tran_pb.set_handle(500) 
-  print "500 valid (yes) ?: " + str(tran_set.isValid(tran_pb))
-  change_set = tran_set.getChangeSet(tran_pb)
-  print "Change set: " + str(change_set)
-  tran_set.purge(tran_pb)
-  print "Change set after purge (same): " + str(change_set)
-
-
-if __name__ == '__main__':
-  main(sys.argv[1:])

=== modified file 'AppDB/cassandra/py_cassandra.py'
--- AppDB/cassandra/py_cassandra.py	2010-05-21 07:13:04 +0000
+++ AppDB/cassandra/py_cassandra.py	2010-06-29 01:49:23 +0000
@@ -1,11 +1,9 @@
 #
 # Cassandra Interface for AppScale
-#
+# Rewritten by Navraj Chohan for using range queries
 # Modified by Chris Bunch for upgrade to Cassandra 0.50.0
 # on 2/17/10
-
-__author__="Soo Hwan Park ([e-mail])"
-__date__="$2009.6.4 19:44:00$"
+# Original author: [e-mail]
 
 import os,sys
 import time
@@ -14,11 +12,9 @@
 from thrift_cass.ttypes import *
 
 import string
-import sys, os
 import base64   # base64    2009.04.16
 from dbconstants import *
 from dbinterface import *
-from dhash_datastore import *
 import sqlalchemy.pool as pool
 import appscale_logger
 
@@ -26,9 +22,12 @@
 from thrift.transport import TSocket
 from thrift.transport import TTransport
 from thrift.protocol import TBinaryProtocol
-
 ERROR_DEFAULT = "DB_ERROR:" # ERROR_CASSANDRA
-
+# Store all schema information in a special table
+# If a table does not show up in this table, try a range query 
+# to discover it's schema
+SCHEMA_TABLE = "__key__"
+SCHEMA_TABLE_SCHEMA = ['schema']
 # use 1 Table and 1 ColumnFamily in Cassandra
 MAIN_TABLE = "Keyspace1"
 COLUMN_FAMILY = "Standard1"
@@ -44,71 +43,219 @@
 CONSISTENCY_QUORUM = 2
 CONSISTENCY_ALL = 5 # don't use this for reads (next version may fix this)
 
-class DatastoreProxy(DHashDatastore):
+MAX_ROW_COUNT = 10000000
+table_cache = {}
+class DatastoreProxy(AppDBInterface):
   def __init__(self, logger = appscale_logger.getLogger("datastore-cassandra")):
-    DHashDatastore.__init__(self, logger)
     # TODO: is this correct?
     f = open(APPSCALE_HOME + '/.appscale/my_public_ip', 'r')
     self.host = f.read()
 #    self.host = host
     self.port = DEFAULT_PORT
-    self.logger.debug("Cassandra connection init to %s:%d" % (self.host, self.port))
     self.pool = pool.QueuePool(self.__create_connection, reset_on_return=False)
+    self.logger = logger
 
   def logTiming(self, function, start_time, end_time):
     if PROFILING:
       self.logger.debug(function + ": " + str(end_time - start_time) + " s")
-
-  ######################################################################
-  # Cassandra specific methods 
-  ######################################################################
-
-  def get(self, key, column = DEFAULT_VALUE):
-    value = None
-    client = None
-    try: 
-      path = ColumnPath(COLUMN_FAMILY, column=column)
-      client = self.__setup_connection()
-      response = client.get(MAIN_TABLE, key, path, CONSISTENCY_QUORUM) 
-#      transport.close()
-
-      value = response.column.value
-    except NotFoundException: # occurs normally if the item isn't in the db
-      return value
-    except Exception, ex:
-      self.logger.debug("Exception %s" % ex)
-    self.__close_connection(client)
-    return value
-
-  def put(self, key, value, column = DEFAULT_VALUE):
-    client = None
-    try:
-      path = ColumnPath(COLUMN_FAMILY, column=column)
-      client = self.__setup_connection()
-      client.insert(MAIN_TABLE, key, path, value, self.timestamp(), CONSISTENCY_QUORUM)
-#      transport.close()
-    except Exception, e :
-      self.logger.debug("put key:%s, column: %s value:%s" % (key, column, value))
-    self.__close_connection(client)
-
-  def remove(self, key, column = ""):
-    client = None
-    try: 
-      client = self.__setup_connection()
-
-      # FIXME: cgb: you'd think that you could just remove the if / else
-      # here, but for some reason it messes up delete if you do
-      # look into why that is
-      if column:
-        path = ColumnPath(COLUMN_FAMILY, column=column)
-        client.remove(MAIN_TABLE, key, path, self.timestamp(), CONSISTENCY_QUORUM)
-      else:
-        path = ColumnPath(COLUMN_FAMILY)
-        client.remove(MAIN_TABLE, key, path, self.timestamp(), CONSISTENCY_QUORUM)
-
-    except Exception, ex: 
-      self.logger.debug("Exception %s" % ex)
-    self.__close_connection(client)
+  
+  def get_entity(self, table_name, row_key, column_names):
+    error = [ERROR_DEFAULT]
+    list = error
+    client = None
+    row_key = table_name + '/' + row_key
+    try: 
+      slice_predicate = SlicePredicate(column_names=column_names)
+      path = ColumnPath(COLUMN_FAMILY)
+      client = self.__setup_connection()
+      # Result is a column type which has name, value, timestamp
+      result = client.get_slice(MAIN_TABLE, row_key, path, slice_predicate,
+                                 CONSISTENCY_QUORUM) 
+      for column in column_names:
+        for r in result:
+          c = r.column
+          if column == c.name:
+            list.append(c.value)
+    except NotFoundException: # occurs normally if the item isn't in the db 
+      list[0] += "Not found"
+      self.__close_connection(client)
+      return list
+    except Exception, ex:
+      #self.logger.debug("Exception %s" % ex)
+      list[0]+=("Exception: %s"%ex)
+      self.__close_connection(client)
+      return list
+    self.__close_connection(client)
+    if len(list) == 1:
+      list[0] += "Not found"
+    return list
+
+
+  def put_entity(self, table_name, row_key, column_names, cell_values):
+    error = [ERROR_DEFAULT]
+    list = error
+    client = None
+
+    # The first time a table is seen
+    if table_name not in table_cache:
+      self.create_table(table_name, column_names)
+
+    row_key = table_name + '/' + row_key
+    try: 
+      client = self.__setup_connection()
+      curtime = self.timestamp()
+      # Result is a column type which has name, value, timestamp
+      mutations = []
+      for index, ii in enumerate(column_names):
+        column = Column(name = ii, value=cell_values[index],
+                      timestamp=curtime)
+        c_or_sc = ColumnOrSuperColumn(column=column)
+        mutation = Mutation(column_or_supercolumn=c_or_sc)
+        mutations.append(mutation)
+      mutation_map = {row_key : { COLUMN_FAMILY : mutations } }
+      client.batch_mutate(MAIN_TABLE, mutation_map,
+                               CONSISTENCY_QUORUM) 
+    except Exception, ex:
+      self.logger.debug("Exception %s" % ex)
+      list[0]+=("Exception: %s"%ex)
+      self.__close_connection(client)
+      list.append("0")
+      return list
+    self.__close_connection(client)
+    list.append("0")
+    return list
+
+  def put_entity_dict(self, table_name, row_key, value_dict):
+    raise NotImplementedError("put_entity_dict is not implemented in %s." % self.__class__)
+
+
+  def get_table(self, table_name, column_names):
+    error = [ERROR_DEFAULT]  
+    client = None
+    result = error
+    keyslices = []
+    column_parent = ColumnParent(column_family="Standard1")
+    predicate = SlicePredicate(column_names=column_names)
+    start_key = table_name
+    end_key = table_name + '~'
+    try: 
+      client = self.__setup_connection()
+      keyslices = client.get_range_slice(MAIN_TABLE, 
+                              column_parent, 
+                              predicate, 
+                              start_key, 
+                              end_key, 
+                              MAX_ROW_COUNT, 
+                              CONSISTENCY_QUORUM)
+    except Exception, ex:
+      self.logger.debug("Exception %s" % ex)
+      result[0] += "Exception: " + str(ex)
+      self.__close_connection(client)
+      return result
+    for keyslice in keyslices:
+      ordering_dict = {}
+      for c in keyslice.columns:
+        column = c.column
+        value = column.value
+        ordering_dict[column.name] = value
+      if len(ordering_dict) == 0:
+        continue
+      for column in column_names:
+        try:
+          result.append(ordering_dict[column])
+        except:
+          result[0] += "Key error, get_table did not return the correct schema"
+    self.__close_connection(client)
+    return result
+
+  def delete_row(self, table_name, row_key):
+    error = [ERROR_DEFAULT]
+    ret = error
+    client = None
+    row_key = table_name + '/' + row_key
+    path = ColumnPath(COLUMN_FAMILY)
+    try: 
+      client = self.__setup_connection()
+      curtime = self.timestamp()
+      # Result is a column type which has name, value, timestamp
+      client.remove(MAIN_TABLE, row_key, path, curtime,
+                               CONSISTENCY_QUORUM) 
+    except Exception, ex:
+      self.logger.debug("Exception %s" % ex)
+      ret[0]+=("Exception: %s"%ex)
+      self.__close_connection(client)
+      return ret 
+    self.__close_connection(client)
+    ret.append("0")
+    return ret
+
+  def get_schema(self, table_name):
+    error = [ERROR_DEFAULT]
+    result = error  
+    ret = self.get_entity(SCHEMA_TABLE, 
+                          table_name, 
+                          SCHEMA_TABLE_SCHEMA)
+    if len(ret) > 1:
+      schema = ret[1]
+    else:
+      error[0] = ret[0] + "--unable to get schema"
+      return error
+    schema = schema.split(':')
+    result = result + schema
+    return result
+
+
+  def delete_table(self, table_name):
+    error = [ERROR_DEFAULT]  
+    result = error
+    keyslices = []
+    column_parent = ColumnParent(column_family="Standard1")
+    predicate = SlicePredicate(column_names=[])
+    curtime = self.timestamp()
+    path = ColumnPath(COLUMN_FAMILY)
+    start_key = table_name
+    end_key = table_name + '~'
+    try: 
+      client = self.__setup_connection()
+      keyslices = client.get_range_slice(MAIN_TABLE, 
+                              column_parent, 
+                              predicate, 
+                              start_key, 
+                              end_key, 
+                              MAX_ROW_COUNT, 
+                              CONSISTENCY_QUORUM)
+    except Exception, ex:
+      self.logger.debug("Exception %s" % ex)
+      result[0]+=("Exception: %s"%ex)
+      self.__close_connection(client)
+      return result
+    keys_removed = False
+    for keyslice in keyslices:
+      row_key = keyslice.key
+      client.remove(MAIN_TABLE, 
+                    row_key, 
+                    path, 
+                    curtime,
+                    CONSISTENCY_QUORUM) 
+      keys_removed = True
+    if table_name not in table_cache and keys_removed:
+      result[0] += "Table does not exist"
+      return  result
+    if table_name in table_cache:
+      del table_cache[table_name]
+ 
+    self.__close_connection(client)
+    return result
+
+  # Only stores the schema
+  def create_table(self, table_name, column_names):
+    table_cache[table_name] = 1
+    columns = ':'.join(column_names)
+    row_key = table_name
+    # Get and make sure we are not overwriting previous schemas
+    ret = self.get_entity(SCHEMA_TABLE, row_key, SCHEMA_TABLE_SCHEMA)
+    if ret[0] != ERROR_DEFAULT:
+      self.put_entity(SCHEMA_TABLE, row_key, SCHEMA_TABLE_SCHEMA, [columns])
 
   ######################################################################
   # private methods 

=== modified file 'AppDB/cassandra/templates/storage-conf.xml'
--- AppDB/cassandra/templates/storage-conf.xml	2010-04-21 11:16:18 +0000
+++ AppDB/cassandra/templates/storage-conf.xml	2010-06-29 01:49:23 +0000
@@ -178,7 +178,7 @@
    ~ directories, since the partitioner can modify the sstable on-disk
    ~ format.
   -->
-  <Partitioner>org.apache.cassandra.dht.RandomPartitioner</Partitioner>
+  <Partitioner>org.apache.cassandra.dht.OrderPreservingPartitioner</Partitioner>
 
   <!--
    ~ If you are using an order-preserving partitioner and you know your key

=== modified file 'AppDB/datastore_tester.py'
--- AppDB/datastore_tester.py	2009-12-02 20:15:14 +0000
+++ AppDB/datastore_tester.py	2010-06-29 01:49:23 +0000
@@ -41,10 +41,10 @@
 #print "columns= " + str(columns)
 #print "data= " + str(data)
 print "table= " + table_name
-app_datastore = appscale_datastore.Datastore(datastore_type)
-
-ERROR_CODES = app_datastore.error_codes()
-if datastore_type not in app_datastore.valid_datastores():
+app_datastore = appscale_datastore.DatastoreFactory.getDatastore(datastore_type)
+ERROR_CODES = appscale_datastore.DatastoreFactory.error_codes()
+VALID_DATASTORES = appscale_datastore.DatastoreFactory.valid_datastores()
+if datastore_type not in VALID_DATASTORES:
   print "Bad selection for datastore. Valid selections are:"
   print app_datastore.valid_datastores()
   exit(1)
@@ -127,10 +127,12 @@
 #################################################
 # Get and a delete on a table that does not exist
 #################################################
+# There is too much overhead in checking to see if the table exists
+# for cassandra
 invalid_table = hf.randomString(10)
-ret = app_datastore.delete_row(invalid_table, key)
-if ret[0] in ERROR_CODES:
-  err(hf.lineno(), ret)
+#ret = app_datastore.delete_row(invalid_table, key)
+#if ret[0] in ERROR_CODES:
+#  err(hf.lineno(), ret)
 ret = app_datastore.get_entity(invalid_table, key, columns)
 if ret[0] in ERROR_CODES:
   err(hf.lineno(), ret)
@@ -186,9 +188,19 @@
 # Get schema on a table that exist, and one that doesnt
 #######################################################
 ret = app_datastore.get_schema(table_name)
-if ret[0] not in ERROR_CODES or ret[1:] != columns:
+if ret[0] not in ERROR_CODES or (ret[1:]).sort() != columns.sort():
+  print "ret[1:]:",ret[1:].sort
+  print "columns:",columns.sort
   err(hf.lineno(), ret)
 ret = app_datastore.get_schema(invalid_table)
 if ret[0] in ERROR_CODES:
   err(hf.lineno(), ret)
+################################################
+# Get data from a table that does not exist
+# Should return an empty list
+################################################
+ret = app_datastore.get_table(invalid_table, columns)
+if ret[0] not in ERROR_CODES and len(ret) != 1:
+  err(hf.lineno(), ret)
+
 print "SUCCESS"

=== modified file 'AppDB/dbinterface.py'
--- AppDB/dbinterface.py	2010-06-25 00:08:24 +0000
+++ AppDB/dbinterface.py	2010-06-29 01:49:23 +0000
@@ -7,19 +7,19 @@
 import os
 
 class AppDBInterface:
-  def get_entity(self, table_name, row_key, column_names):  
+  def get_entity(self, table_name, row_key, column_names, txnid = 0):  
     raise NotImplementedError("get_entity is not implemented in %s." % self.__class__)
 
-  def put_entity(self, table_name, row_key, column_names, cell_values):
+  def put_entity(self, table_name, row_key, column_names, cell_values, txnid = 0):
     raise NotImplementedError("put_entity is not implemented in %s." % self.__class__)
 
   def put_entity_dict(self, table_name, row_key, value_dict):
     raise NotImplementedError("put_entity_dict is not implemented in %s." % self.__class__)
 
-  def get_table(self, table_name, column_names):
+  def get_table(self, table_name, column_names, txnid = 0):
     raise NotImplementedError("get_table is not implemented in %s." % self.__class__)
 
-  def delete_row(self, table_name, row_id):
+  def delete_row(self, table_name, row_id, txnid = 0):
     raise NotImplementedError("delete_row is not implemented in %s." % self.__class__)
 
   def get_schema(self, table_name):
@@ -28,6 +28,14 @@
   def delete_table(self, table_name):
     raise NotImplementedError("delete_table is not implemented in %s." % self.__class__)
 
+  def commit(self, txnid):
+    raise NotImplementedError("commit is not implemented in %s." % self.__class__)
+  def rollback(self, txnid):
+    raise NotImplementedError("rollback is not implemented in %s." % self.__class__)
+  def setupTransaction(self, txnid):
+    raise NotImplementedError("rollback is not implemented in %s." % self.__class__)
+    
+
   def get_local_ip(self):
     try:
       local_ip = self.__local_ip

=== modified file 'AppDB/dhash_datastore.py'
--- AppDB/dhash_datastore.py	2010-05-05 23:27:52 +0000
+++ AppDB/dhash_datastore.py	2010-06-29 01:49:23 +0000
@@ -217,9 +217,9 @@
     if self.remove_key(row_id, table_name):
       self.remove(internal_key)
       return elist
-    else:
-      elist[0] += "row doesn't exist"
-      return elist
+    #else:
+    elist.append("0")
+    return elist
 
   def get_schema(self, table_name):
     self.logger.debug("get_schema: %s" % table_name) 

=== modified file 'AppDB/hbase/py_hbase.py'
--- AppDB/hbase/py_hbase.py	2010-05-21 07:13:04 +0000
+++ AppDB/hbase/py_hbase.py	2010-06-29 01:49:23 +0000
@@ -1,11 +1,9 @@
 #Author: Navraj Chohan
 
-import os,sys
+import os
 
 import Hbase
 import ttypes
-import string
-import threading
 import time
 from thrift import Thrift
 from thrift.transport import TSocket
@@ -85,15 +83,12 @@
       column_names = client.getColumnDescriptors(table_name)
       keys = column_names.keys()
 
-      table = get_table(table_name, keys)
+      table = self.get_table(table_name, keys)
       value = (len(table) - 1)/(len(keys))
       elist.append(value)
     except ttypes.IOError, io:
       elist[0] = elist[0] + "Row Count. IO Error--" + io.message
       value = 0
-    except ttypes.IOException, io:
-      elist[0] = elist[0] + "Row Count. IO Exception--" + io.message
-      value = 0  
     self.__closeConnection(client)
     et = time.time()
     self.logTiming("HB ROWCOUNT", st, et)
@@ -272,7 +267,10 @@
       client.scannerClose(scanner) 
     except ttypes.IOError, io:
       if io.message:
-        elist[0] += "IO Error--" + str(io.message)
+        if io.message == table_name:
+          pass # Return an empty table
+        else:
+          elist[0] += "IO Error--" + str(io.message)
       else:
         elist[0] += "IOError"
     except ttypes.IllegalArgument, e:

=== modified file 'AppDB/helper_functions.py'
--- AppDB/helper_functions.py	2009-12-01 07:13:55 +0000
+++ AppDB/helper_functions.py	2010-06-29 01:49:23 +0000
@@ -57,7 +57,7 @@
 
 def randomString(length):
   s = hashlib.sha256()
-  ret = ""
+  ret = "a"
   while len(ret) < length:
     s.update(str(random.random()))
     ret += s.hexdigest()

=== modified file 'AppDB/hypertable/py_hypertable.py'
--- AppDB/hypertable/py_hypertable.py	2010-05-21 07:13:04 +0000
+++ AppDB/hypertable/py_hypertable.py	2010-06-29 01:49:23 +0000
@@ -142,6 +142,8 @@
     if PROFILING:
       self.logger.debug("HT GET: %s"%str(endtime - starttime))
     self.__closeConnection(client)
+    if len(elist) == 1:
+      elist[0] += "Not Found"
     return elist
 
   def delete_table(self, table_name):
@@ -173,7 +175,10 @@
     if not self.__table_exist(table_name):
       query = "create table " + table_name + "( " + ', '.join(column_names) + ")"
       print "create table query=%s" % query
-      ret = client.hql_query(query)
+      try:
+        ret = client.hql_query(query)
+      except Exception, e:
+        print e.message
 # the xml schema is not working currectly.
 #      schema = "<Schema><AccessGroup name=\"default\"><ColumnFamily>"
 #      for column in column_names:
@@ -269,7 +274,8 @@
         if res[ii].column_family in column_names:
           elist += [res[ii].value]
     except:
-      elist[0] += "Not Found"
+      pass
+      #elist[0] += "Not Found"
     endtime = time.time()
     if PROFILING:
       self.logger.debug("HT GET_TABLE: %s"%str(endtime - starttime))

=== modified file 'AppDB/mongodb/py_mongodb.py'
--- AppDB/mongodb/py_mongodb.py	2010-04-08 23:58:23 +0000
+++ AppDB/mongodb/py_mongodb.py	2010-06-29 01:49:23 +0000
@@ -74,6 +74,8 @@
 
     elist.append("0")
     self.__close_connection(db)
+    if len(elist) == 1:
+      elist[0] += "Not found"
     return elist
 
   def create_table(self, table_name, columns):
@@ -166,6 +168,8 @@
           if column == schema[ii]:
             elist.append(data[ii])
       self.__close_connection(db)
+      if len(elist) == 1:
+        elist[0] += "Not found"
       return elist
 
   def get_schema(self, table_name):
@@ -222,8 +226,8 @@
               usedRows.append(myRow)
 
 
-      if(len(elist) == 1):
-        elist[0] += "table not found"
+      #if len(elist) == 1:
+      #  elist[0] += "table not found"
 
       self.__close_connection(db)
       return elist

=== modified file 'AppDB/mysql/drop_all_tables.py'
--- AppDB/mysql/drop_all_tables.py	2009-07-20 08:49:28 +0000
+++ AppDB/mysql/drop_all_tables.py	2010-06-29 01:49:23 +0000
@@ -21,7 +21,7 @@
 SLAVES_FILE = APPSCALE_HOME + "/.appscale/slaves"
 #DB_LOCATION = socket.gethostbyname(socket.gethostname())
 DB_LOCATION = "127.0.0.1"
-DATABASE = "test"
+DATABASE = "appscale"
 def set_db_location():
   global DB_LOCATION
   file = open(SLAVES_FILE, "r")
@@ -34,6 +34,9 @@
     cursor = client.cursor()
     cursor.execute("DROP DATABASE " + DATABASE)
     cursor.execute("CREATE DATABASE " + DATABASE) 
+    cursor.close()
+    client.commit()
+    client.close()
   except MySQLdb.Error, e:
     print e.args[1]
     return 0  

=== modified file 'AppDB/mysql/prime_mysql.py'
--- AppDB/mysql/prime_mysql.py	2010-05-27 21:59:59 +0000
+++ AppDB/mysql/prime_mysql.py	2010-06-29 01:49:23 +0000
@@ -3,18 +3,17 @@
 
 import sys, time
 import os 
+import MySQLdb
+import _mysql
+import socket
+from dbconstants import *
+
 
 APPSCALE_HOME = os.environ.get("APPSCALE_HOME")
 if APPSCALE_HOME:
   pass
 else:
   print "APPSCALE_HOME env var not set"
-  APPSCALE_HOME = "/root/appscale/"
-
-import MySQLdb
-import _mysql
-import socket
-from dbconstants import *
 
 ROW_KEY = "mysql__row_key__"
 SLAVES_FILE = APPSCALE_HOME + "/.appscale/slaves"
@@ -27,13 +26,23 @@
   DB_LOCATION = file.readline()
   file.close()
 
+def drop_database():
+  client = MySQLdb.connect(host=DB_LOCATION, db="mysql")
+  cursor = client.cursor()
+  cursor.execute("DROP DATABASE IF EXISTS appscale;")
+  cursor.close()
+  client.commit()
+  client.close()
+
 def create_database():
   client = MySQLdb.connect(host=DB_LOCATION, db="mysql")
   cursor = client.cursor()
-  cursor.execute("drop database if exists appscale;")
-  cursor.execute("create database appscale;")
+  cursor.execute("CREATE DATABASE IF NOT EXISTS appscale;")
+  cursor.close()
+  client.commit()
   client.close()
 
+
 def create_table(tablename, columns):
   try:
     client = MySQLdb.connect(host=DB_LOCATION, db="appscale")
@@ -43,13 +52,16 @@
       columnscopy += ["x" + columns[ii]]
     command = "CREATE TABLE IF NOT EXISTS " + tablename + "( " + ROW_KEY + " CHAR(80) primary key, " + ' MEDIUMBLOB, '.join(columnscopy) + " MEDIUMBLOB) ENGINE=NDBCLUSTER"
     print command
-    cursor.execute(command)
+    print cursor.execute(command)
   except MySQLdb.Error, e:
     print e.args[1]
     return 0
+  cursor.close()
+  client.commit()
   client.close()
   return 1
 
+drop_database()
 create_database()
 
 def prime_mysql():

=== modified file 'AppDB/mysql/py_mysql.py'
--- AppDB/mysql/py_mysql.py	2010-03-15 22:22:12 +0000
+++ AppDB/mysql/py_mysql.py	2010-06-29 01:49:23 +0000
@@ -1,16 +1,17 @@
 # Author: Navraj Chohan
-import sys
+#import sys
 import os
-import string
 import MySQLdb
-import _mysql
-import base64
-import sqlalchemy.pool as pool
+#import _mysql
+#import sqlalchemy.pool as pool
 from dbinterface import *
 import appscale_logger
-
-MySQLdb = pool.manage(MySQLdb)
-
+import threading
+import time
+#MySQLdb = pool.manage(MySQLdb)
+TIMEOUT = 30
+# Time till next gc of connections
+GC_TIME = 120
 ROW_KEY = "mysql__row_key__"
 ERROR_MY = "DB_ERROR:"
 #DB_LOCATION = "appscale-image"
@@ -18,22 +19,47 @@
 DB_LOCATION = "127.0.0.1"
 #DB_PORT = 3306
 DEBUG = False
-
+transDict = {}
+transDict_lock = threading.Lock()
+last_gc_time = 0
 class DatastoreProxy(AppDBInterface):
 
   def __init__(self, log = appscale_logger.getLogger("datastore-mysql")):
     self.logger = log
     self.client = None
+    self.transactionsOn = False
+
+
+  def commit(self, txnid):
+    elist = [ERROR_MY]
+    try:
+      cursor, client = self.__get_connection(txnid)
+      cursor.close()
+      client.commit()
+      self.__close_connection(txnid) 
+    except MySQLdb.Error, e:
+      if DEBUG: self.logger.info(str(e.args[0]) + "--" + e.args[1])
+      elist[0] = ERROR_MY + str(e.args[0]) + "--" + e.args[1]
+    return elist 
+
+  def rollback(self, txnid):
+    elist = [ERROR_MY]
+    try:
+      cursor, client = self.__get_connection(txnid)
+      cursor.close()
+      client.rollback()
+      self.__close_connection(txnid)
+    except MySQLdb.Error, e:
+      elist[0] = ERROR_MY + str(e.args[0]) + "--" + e.args[1] 
+    return elist
 
   def get_schema(self, table_name):
     table_name = "x" + table_name
     elist = [ERROR_MY]
     client = None
     try: 
-      client = self.__get_connection()
-      client.autocommit(1)
+      client = MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
       cursor = client.cursor()
-#      cursor.execute(USE_DATABASE)
       command = "SHOW fields FROM " + table_name
       cursor.execute(command)
       while (1):
@@ -50,6 +76,7 @@
       if DEBUG: print str(e.args[0]) + "--" + e.args[1] 
       elist[0] = ERROR_MY + "Unable to get schema"
     if client:
+      client.commit()
       client.close()
     return elist
 
@@ -58,10 +85,8 @@
     elist = [ERROR_MY]
     client = None
     try:
-      client = self.__get_connection()
-      client.autocommit(1)
+      client = MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
       cursor = client.cursor()
-#      cursor.execute(USE_DATABASE)
       command = "drop table " + table_name
       if DEBUG: self.logger.info(command)
       cursor.execute(command)
@@ -69,23 +94,29 @@
       elist[0] += str(e.args[0]) + "--" + e.args[1]
     if DEBUG: self.logger.info(elist)
     if client:
+      client.commit()
       client.close()
     return elist
 
-  def get_entity(self, table_name, row_key, column_names):
+  def get_entity(self, table_name, row_key, column_names, txnid = 0):
     table_name = "x" + table_name
     elist = [ERROR_MY]
     client = None
+    isTrans = False
+    if txnid != 0 and self.transactionsOn:
+      isTrans = True
     if not row_key:
       self.logger.info("Null row key")
       elist[0] += "Null row key"
       return elist
 
     try:
-      client = self.__get_connection()
-      client.autocommit(1)
-      cursor = client.cursor()
-#      cursor.execute(USE_DATABASE)
+      if not isTrans:
+        client = MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
+        cursor = client.cursor()
+      else:  
+        cursor, client = self.__get_connection(txnid)
+
       command = "select "
       # Hacking on a x to make sure all columns start with a letter
       columncopy = []
@@ -99,32 +130,35 @@
       cursor.execute(command)
       result = cursor.fetchone()
       if result == None:
-        client.close()
+        if not isTrans:
+          client.close()
         if len(elist) == 1:
           elist[0] += "Not found"
         return elist
       for ii in range(0, len(result)):
-        #elist += [result[ii]]
         if result[ii]:
-          #elist += [base64.b64decode(result[ii])]
           elist.append(result[ii])
         else:
           elist.append('')
     except MySQLdb.Error, e:
       if e.args[1].find("exists") == -1:
-        client.close()
+        if not isTrans:
+          client.close()
         if len(elist) == 1:
           elist[0] += "Not found"
         return elist
       elist[0] = ERROR_MY + str(e.args[0]) + "--" + e.args[1] 
     if DEBUG: self.logger.info(elist)
-    if client:
+    
+    if client and not isTrans:
       client.close()
     if len(elist) == 1:
       elist[0] += "Not found"
     return elist
 
-  def put_entity(self, table_name, row_key, column_names, cell_values):
+  def put_entity(self, table_name, row_key, column_names, cell_values, txnid = 0):
+    # Hacking on a x to make sure all columns start with a letter
+    # Mysql limitation
     table_name = "x" + table_name
     if DEBUG: self.logger.info("PUT ENTITY")
     if DEBUG: self.logger.info(str(cell_values))
@@ -135,28 +169,43 @@
       self.logger.info("Null row key")
       elist[0] += "Null row key"
       return elist
-    # Hacking on a x to make sure all columns start with a letter
     columncopy = []
     for ii in range(0, len(column_names)):
       columncopy.append("x" + column_names[ii])
-    try:
-      client = self.__get_connection()
-      client.autocommit(1)
-      cursor = client.cursor()
-#      cursor.execute(USE_DATABASE)
+
+    # TODO This should be reactive, if a put fails due to no table, create it
+    try:
+      tempclient = MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
+      query = "CREATE TABLE IF NOT EXISTS " + table_name + " ( " + ROW_KEY + " CHAR(255) primary key, " + ' BLOB, '.join(columncopy) + " BLOB) ENGINE=NDBCLUSTER" 
+      tempcursor = tempclient.cursor()
+      if DEBUG: self.logger.info(query)
+      result = tempcursor.execute(query)
+      if DEBUG: self.logger.info("DONE CREATING TABLE...%s",str(result))
+    except MySQLdb.Error, e:
+      error = ERROR_MY + str(e.args[0]) + "--" + e.args[1] 
+      print error
+      tempcursor.close()
+      tempclient.commit()
+      tempclient.close()
+
+    isTrans = False
+    if txnid != 0 and self.transactionsOn:
+      isTrans = True
+    try:
+      if not isTrans:
+        client = MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
+        cursor = client.cursor()
+      else:  
+        cursor, client = self.__get_connection(txnid)
 
       if len(column_names) != len(cell_values):
         elist[0] += "Error in put call |column_names| != |cell_values|"
-        client.close()
+        if not isTrans:
+          client.close()
         return elist 
-      query = "CREATE TABLE IF NOT EXISTS " + table_name + " ( " + ROW_KEY + " CHAR(255) primary key, " + ' BLOB, '.join(columncopy) + " BLOB) ENGINE=NDBCLUSTER" 
-      if DEBUG: self.logger.info(query)
-      result = cursor.execute(query)
-      if DEBUG: self.logger.info("DONE CREATING TABLE...%s",str(result))
       values = []
       for ii in range(0, len(cell_values)):
         if cell_values[ii]:
-          #value = base64.b64encode(cell_values[ii])
           value = cell_values[ii]
           values.append(MySQLdb.escape_string(value))
         else:
@@ -178,8 +227,6 @@
         command += "%s)"
         if DEBUG: self.logger.info(command)
         cursor.execute(command, tuple(cell_values + [MySQLdb.escape_string(row_key)])) 
-        cursor.close()
-        cursor = ""
       else:
         # do an update 
         for ii in range(0, len(cell_values)):
@@ -196,13 +243,15 @@
     elist.append("0")
     if DEBUG: self.logger.info(elist)
     if DEBUG: self.logger.info("DONE WITH PUT ENTITY")
-    if client:
+    if client and not isTrans:  
+      cursor.close()
+      client.commit()
       client.close()
     return elist 
 
   def __table_exist(self, table_name):
     table_name = "x" + table_name
-    client = self.__get_connection()
+    client = MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
     cursor = client.cursor()
 #    cursor.execute(USE_DATABASE)
     cursor.execute('show tables')
@@ -211,18 +260,30 @@
       if row == None:
         break;
       if table_name == row[0]:
+        client.close()
         return 1
+    
+    cursor.close()
+    client.commit()
+    client.close()
     return 0
 
-  def delete_row(self, table_name, row_key):
+  def delete_row(self, table_name, row_key, txnid = 0):
     table_name = "x" + table_name
     if DEBUG: self.logger.info("DELETE ROW")
     client = None
+ 
+    isTrans = False
+    if txnid != 0 and self.transactionsOn:
+      isTrans = True
     elist = [ERROR_MY]
     try:
-      client = self.__get_connection()
-      client.autocommit(1)
-      cursor = client.cursor()
+      if txnid == 0 or not self.transactionsOn:
+        client = MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
+        #client.autocommit(0)
+        cursor = client.cursor()
+      else:  
+        cursor, client = self.__get_connection(txnid)
 #      cursor.execute(USE_DATABASE)
       row_key = MySQLdb.escape_string(row_key)
       query = "delete from " + table_name + " WHERE " + ROW_KEY + "= '" + row_key + "'" 
@@ -232,7 +293,8 @@
       elist[0] = ERROR_MY + str(e.args[0]) + "--" + e.args[1] 
     if DEBUG: self.logger.info(elist)
     if DEBUG: self.logger.info("DELETING ROW")
-    if client:
+    if client and not isTrans:
+      client.commit()
       client.close()
     return elist
 
@@ -242,8 +304,8 @@
     client = None
     elist = [ERROR_MY]
     try:
-      client = self.__get_connection()
-      client.autocommit(1)
+      client = MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
+      #client.autocommit(0)
       cursor = client.cursor()
 #      cursor.execute(USE_DATABASE)
       query = "SELECT COUNT(*) FROM " + table_name 
@@ -255,18 +317,22 @@
     if DEBUG: self.logger.info(elist)
     if DEBUG: self.logger.info("DONE WITH ROW COUNT")
     if client:
+      cursor.close()
       client.close()
     return elist
 
-  def get_table(self, table_name, column_names):
+  def get_table(self, table_name, column_names, txnid = 0):
     table_name = "x" + table_name
     if DEBUG: self.logger.info("GET TABLE")
     client = None
     elist = [ERROR_MY]
     try:
-      client = self.__get_connection()
-      client.autocommit(1)
-      cursor = client.cursor()
+      if txnid == 0 or not self.transactionsOn:
+        client = MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
+        #client.autocommit(0)
+        cursor = client.cursor()
+      else:  
+        cursor, client = self.__get_connection(txnid)
 #      cursor.execute(USE_DATABASE)
       # Hacking on a letter to make sure all columns start with a letter
       columncopy = []
@@ -294,15 +360,15 @@
     if DEBUG: self.logger.info(str(elist))
     if DEBUG: self.logger.info("DONE GETTING TABLE")
     if client:
-      client.close()
+      if not self.transactionsOn or txnid == 0:
+        cursor.close()
+        client.close()
     return elist
 
   def __query_table(self, table_name):
     table_name = "x" + table_name
     client = self.__get_connection()
-    client.autocommit(1)
     cursor = client.cursor()
-#    cursor.execute(USE_DATABASE)
     cursor.execute("select * from " + table_name )
     elist = []
     while (1):
@@ -310,9 +376,63 @@
       if row == None:
         break
       elist.append(row)
+    if cursor:
+      cursor.close()
     if client:
+      client.commit()
       client.close()
     return elist
 
-  def __get_connection(self):
-    return MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
+  def __get_connection(self, txnid):
+    client = None
+    cursor = None
+    self.__gc()
+    
+    transDict_lock.acquire()
+    if txnid in transDict:
+      cursor, client, start_time = transDict[txnid] 
+    transDict_lock.release()
+    if not client:
+      raise MySQLdb.Error(1, "Connection timed out")
+    return cursor, client 
+
+  # clean up expired connections
+  def __gc(self):
+    global last_gc_time
+    curtime = time.time()
+    if curtime < last_gc_time + GC_TIME:
+      return
+    transDict_lock.acquire()
+    del_list = []
+    for ii in transDict:
+      cu, cl, st = transDict[ii]
+      if st + TIMEOUT < curtime:
+        del_list.append(ii)    
+    # safe deletes
+    del_list.reverse()
+    for ii in del_list:
+      del transDict[ii]
+    transDict_lock.release()
+    last_gc_time = time.time() 
+
+  def setupTransaction(self, txnid):
+    self.transactionsOn = True
+    # New connection 
+    client = MySQLdb.connect(host=DB_LOCATION, db=USE_DATABASE)
+    #client.autocommit(0)
+    cursor = client.cursor()
+    transDict_lock.acquire()
+    transDict[txnid] = cursor, client, time.time()
+    transDict_lock.release()
+
+  def __close_connection(self, txnid):
+    transDict_lock.acquire()
+    if txnid in transDict:
+      cursor, client, start_time = transDict[txnid]
+      cursor.close()
+      client.close()
+      del transDict[txnid]
+    transDict_lock.release()
+    return 
+
+

=== added file 'AppDB/mysql/test_mysql_trans.py'
--- AppDB/mysql/test_mysql_trans.py	1970-01-01 00:00:00 +0000
+++ AppDB/mysql/test_mysql_trans.py	2010-06-29 01:49:23 +0000
@@ -0,0 +1,115 @@
+import py_mysql
+import random
+#over write the import
+py_mysql = py_mysql.DatastoreProxy()
+columns = ["a","b","c"]
+data = ["1","2","3"]
+invalid_data = ['y','y','y']
+table_name = "hello"
+key = "1"
+print "key= " + key
+print "columns= " + str(columns)
+print "data= " + str(data)
+print "table= " + table_name
+txn = random.randint(0,100000000)
+py_mysql.setupTransaction(txn)
+print "Test: Transaction number:",txn
+py_mysql.put_entity(table_name, key, columns, invalid_data, txn)
+ret = py_mysql.get_entity(table_name, key, columns, txn)
+print "Test: Invalid:"
+print ret
+ret = py_mysql.get_entity(table_name, key, columns)
+print "Test: Outside transaction:"
+print ret
+print py_mysql.put_entity(table_name, key, columns, data, txn)
+print "Test: GET"
+ret = py_mysql.get_entity(table_name, key, columns, txn)
+print "Test: Valid:"
+print ret
+print "Test: Committing:"
+#print py_mysql.commit(txn)
+print ret
+if ret[1:] != data:
+  print "ERROR doing a put then get. Data does not match"
+  print "returned: " + str(ret)
+  print "expected: " + str(data)
+  exit(1)
+else: 
+  print "Success"
+py_mysql.commit(txn)
+print "After committed transaction:"
+ret = py_mysql.get_entity(table_name, key, columns)
+print ret
+txn = random.randint(0,100000000)
+py_mysql.setupTransaction(txn)
+txn2 = random.randint(0,11000000000)
+py_mysql.setupTransaction(txn2)
+print "Transaction number:",txn
+print "PUT:"
+print py_mysql.put_entity(table_name, key, columns, invalid_data, txn)
+print "outside transaction:"
+ret = py_mysql.get_entity(table_name, key, columns,txn2)
+print ret
+print "inside transaction:"
+ret = py_mysql.get_entity(table_name, key, columns, txn)
+print ret
+print py_mysql.put_entity(table_name, key, columns, invalid_data, txn)
+print "Rollback:"
+print py_mysql.rollback(txn)
+print "doing a put, rollback, then get"
+print "GET"
+ret = py_mysql.get_entity(table_name, key, columns)
+print "doing a put then get"
+print ret
+if ret[1:] != data:
+  print "*" * 60
+  print "FAILURE doing a put then get. Data does not match"
+  print "returned: " + str(ret)
+  print "expected: " + str(data)
+  print "*" * 60
+  exit(1)
+else: 
+  print "Success"
+
+ret = py_mysql.get_schema("hello")
+print ret
+print "checking schema:"
+print ret
+if ret[1:] != columns:
+  print "ERROR in recieved schema"
+  print "returned: " + str(ret)
+  print "expected: " + str(columns)
+
+#ret = py_mysql.__table_exist(table_name)
+#print "Does table we just created exist?"
+#print ret
+
+ret = py_mysql.delete_row(table_name, key)
+print "Deleting the key %s"%key
+print ret
+
+ret = py_mysql.get_entity(table_name, key, columns)
+print "Trying to get deleted key:"
+print ret
+print "doing a put with key %s"%key
+print py_mysql.put_entity("hello", "1", ["a","b","c"], ["1","2","3"])
+print "doing a get table" 
+print py_mysql.get_table("hello", ["a","b","c"])
+py_mysql.put_entity("hello", "2", ["a","b","c"], ["4","5","6"])
+print "doing get table:"
+print py_mysql.get_table("hello", ["a","b","c"])
+py_mysql.put_entity("hello", "3", ["a","b","c"], ["1","2","3"])
+py_mysql.get_table("hello", ["a","b","c"])
+
+print "TRYING TO REPLACE KEY 3"
+py_mysql.put_entity("hello", "3", ["a","b","c"], ["1","2","3"])
+py_mysql.get_table("hello", ["a","b","c"])
+py_mysql.get_row_count("hello")
+ret = py_mysql.delete_row("hello", "1")
+ret = py_mysql.delete_row("hello", "2")
+ret = py_mysql.delete_row("hello", "3")
+py_mysql.get_table("hello", ["a","b","c"])
+print "Deleting table:"
+print py_mysql.delete_table("hello")
+print "deleting twice:"
+print py_mysql.delete_table("hello")

=== modified file 'AppDB/soap_server.py'
--- AppDB/soap_server.py	2010-03-16 21:22:28 +0000
+++ AppDB/soap_server.py	2010-06-29 01:49:23 +0000
@@ -34,7 +34,7 @@
 DEFAULT_APP_LOCATION = ".flatfile_apps"
 DEFAULT_DATASTORE = "hbase"
 DEFAULT_SSL_PORT = 4343
-DEFAULT_PORT = 8080
+DEFAULT_PORT = 9899
 IP_TABLE = "IPS___"
 DEFAULT_ENCRYPTION = 1
 VALID_DATASTORES = []   

=== modified file 'AppDB/voldemort/py_voldemort.py'
--- AppDB/voldemort/py_voldemort.py	2010-05-03 21:02:23 +0000
+++ AppDB/voldemort/py_voldemort.py	2010-06-29 01:49:23 +0000
@@ -47,12 +47,14 @@
   def get(self, key):
     done = False
     timeout = RETRY_TIMEOUT
-    while (done != True):
+    while (done != True and timeout > 0):
       try:
         value = self.real_get(key)
         done = True
       except:
         timeout -= 1
+    if timeout <= 0:
+      raise
     return value
 
   def real_get(self, key):
@@ -88,6 +90,8 @@