← Back to branch summary

~appscale-maintainers/appscale/1.4

« back to all changes in this revision

Viewing changes to AppDB/memcachedb/py_memcachedb.py

  • Committer: Chris Bunch
  • Author(s): NOMURA Yoshihide
  • Date: 2010-08-20 19:40:24 UTC
  • mfrom: (546.4.4 appscale)
  • Revision ID: cgb@cs.ucsb.edu-20100820194024-o10jcztjeqwjpelo
Changed dhash_datastore to split the metakey into 16 pieces to improve multi client throughput.

Show diffs side-by-side

added added

removed removed

Lines of Context:
AppDB/memcachedb/py_memcachedb.py
12
12
from dhash_datastore import *
13
13
import sqlalchemy.pool as pool
14
14
import appscale_logger
 
15
import hashlib
15
16
 
16
17
PROFILING = False
17
18
DB_LOCATION = "localhost"
18
19
DB_PORT = 30000
 
20
# Use md5 key instead of real key.
 
21
# Hashkey doesn't have key length restriction,
 
22
# but there is a possibility of key conflict.
 
23
USE_HASHKEY = False
19
24
 
20
25
class DatastoreProxy(DHashDatastore):
21
26
  def __init__(self, logger = appscale_logger.getLogger("datastore-memcachedb")):
22
27
    DHashDatastore.__init__(self, logger)
23
28
  #  self.pool = pool.SingletonThreadPool(self.__createConnection, echo=True)
24
 
  #  self.pool = pool.QueuePool(self.__createConnection, reset_on_return=False)
 
29
#    self.localpool = pool.QueuePool(self.__createLocalConnection)
 
30
#    self.masterpool = pool.QueuePool(self.__createMasterConnection)
 
31
    self.masterclient = self.__createMasterConnection()
 
32
    self.localclient = self.__createLocalConnection()
25
33
 
26
34
  def logTiming(self, function, start_time, end_time):
27
35
    if PROFILING:
42
50
  def __createMasterConnection(self):
43
51
    return self.__createConnection(self.get_master_ip())
44
52
 
45
 
  def __initConnection(self):
46
 
    st = time.time()
47
 
    #client = self.pool.connect()
48
 
    client = self.__createConnection()
49
 
    return client
50
 
#    et = time.time()
51
 
#    logTiming("MC Init Connection", st, et)
52
 
#    return
 
53
  def __getLocalConnection(self):
 
54
    return self.localclient
 
55
#    return self.localpool.connect()
 
56
 
 
57
  def __getMasterConnection(self):
 
58
    return self.masterclient
 
59
#    return self.masterpool.connect()
53
60
 
54
61
  def __closeConnection(self, conn):
55
62
    pass
56
 
    #if conn:
57
 
    #  conn.close()
 
63
#    if conn:
 
64
#      conn.close()
 
65
 
 
66
  def __encodekey(self, key):
 
67
    if USE_HASHKEY:
 
68
      # create hash key from actual key.
 
69
      m = hashlib.md5()
 
70
      m.update(key)
 
71
      return m.hexdigest()
 
72
    else:
 
73
      return key.encode()
58
74
 
59
75
  def get(self, key):
60
76
    self.logger.debug("getting [%s]" % key)
61
77
    if key is None:
62
78
      return None
63
 
    client = self.__createLocalConnection()
64
 
    key = key.encode()
 
79
    client = self.__getLocalConnection()
 
80
    key = self.__encodekey(key)
65
81
    value = client.get(key)
66
82
    self.__closeConnection(client)
67
83
    return value
68
84
 
69
85
  def put(self, key, value):
70
 
    client = self.__createMasterConnection()
71
 
    key = key.encode()
 
86
    client = self.__getMasterConnection()
 
87
    key = self.__encodekey(key)
72
88
    value = value.encode()
73
89
    result = client.set(key, value)
74
90
    self.logger.debug("set [%s],[%s] returned %s" % (str(key), str(value), str(result)))
76
92
    return result
77
93
 
78
94
  def remove(self, key):
79
 
    client = self.__createMasterConnection()
80
 
    key = key.encode()
 
95
    client = self.__getMasterConnection()
 
96
    key = self.__encodekey(key)
81
97
    result = client.delete(key)
82
98
    self.logger.debug("remove key [%s] returned [%s]" % (str(key), str(result)))
83
99
    self.__closeConnection(client)
84
100
    return result
85
101
 
86
102
  def get_all(self, key_list):
87
 
    client = self.__createLocalConnection()
88
 
    key_list = [key.encode() for key in key_list]
 
103
    client = self.__getLocalConnection()
 
104
    key_list = [self.__encodekey(key) for key in key_list]
89
105
    key_vals = client.get_multi(key_list)
90
106
    result = [key_vals[key] for key in key_list]
91
107
    self.logger.debug("get multi [%s] returned [%s]" % (str(key_list), str(result)))