python 内存数据库与远程服务

需要import的python 内存数据库代码参考下面的链接：

http://blog.csdn.net/ubuntu64fan/article/details/50424683

现在的问题：

创建一个内存数据服务，可以供本地或远程用户连接上来，多个用户同时并发读写

这个内存数据库。

解决的步骤有3:

（1) 创建服务器(memdb_server.py)

（2) 创建客户端(memdb_client.py)

（3) 启动服务器，启动客户端

1 服务器代码：

#!/usr/bin/python
#-*- coding: UTF-8 -*-
# memdb_server.py
#
# Queues are thread and process safe.
# Refer:
#   https://docs.python.org/2/library/multiprocessing.html
#
########################################################################
# The MIT License (MIT)
#    http://opensource.org/licenses/MIT
#
#  Copyright (c) 2015 copyright cheungmine
#
# Permission is hereby granted, free of charge, to any person obtaining
#  a copy of this software and associated documentation files (the
#  "Software"), to deal in the Software without restriction, including
#  without limitation the rights to use, copy, modify, merge, publish,
#  distribute, sublicense, and/or sell copies of the Software, and to
#  permit persons to whom the Software is furnished to do so, subject
#  to the following conditions:
#
# The above copyright notice and this permission notice shall be
#  included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
########################################################################

from multiprocessing.managers import BaseManager
from multiprocessing import RLock

from memdb import MemDB
from memdb import MemDBConnect

# global variables
#
lock = RLock()

memdbConn = MemDBConnect(MemDB())

class MemDBManager(BaseManager): pass

# thread safe class
#
class MemDBConnectProxy(object):
    global memdbConn

    def QueryTables(self):
        return memdbConn.QueryTablesNothrow()

    def QueryTableKeys(self, tablename):
        return memdbConn.QueryTableKeysNothrow(tablename)

    def CreateTable(self, tablename):
        memdbConn.CreateTableNothrow(tablename)
        pass

    def DropTable(self, tablename):
        memdbConn.DropTableNothrow(tablename)
        pass

    def GetValue(self, tablename, key, defaultvalue):
        return memdbConn.GetValueNothrow(tablename, key, defaultvalue)

    def AddValue(self, tablename, key, value):
        return memdbConn.AddValueNothrow(tablename, key, value)

    def DelValue(self, tablename, key):
        memdbConn.DelValueNothrow(tablename, key)

    def AppendValueList(self, tablename, key, value, non_repeated_value):
        memdbConn.AppendValueListNothrow(tablename, key, value, non_repeated_value)

    def AppendValueListMulti(self, tablenames, keys, values, non_repeated_values):
        memdbConn.AppendValueListMultiNothrow(tablenames, keys, values, non_repeated_values)

###########################################################
#
class MemDBManagerServer:
    MemDBManager.register(‘get_lock‘, callable=lambda: lock)
    MemDBManager.register(‘MemDBConnect‘, MemDBConnectProxy)

    def __init__(self, host, port, passkey):
        self.manager = MemDBManager(address=(host, port), authkey=passkey)
        self.server = self.manager.get_server()
        pass

    def start(self):
        self.server.serve_forever()
        pass

    def stop(self):
        self.server.shutdown()
        self.stop_flag = 1
        pass

###########################################################
# start(‘‘, 12345, ‘abc‘)
#
def start(host, port, passkey):
     from memdb_server import MemDBManagerServer

     server = MemDBManagerServer(host, port, passkey)
     server.start()

2 客户端代码:

#!/usr/bin/python
#-*- coding: UTF-8 -*-
# memdb_client.py
#
# Queues are thread and process safe.
#
########################################################################
# The MIT License (MIT)
#    http://opensource.org/licenses/MIT
#
#  Copyright (c) 2015 copyright cheungmine
#
# Permission is hereby granted, free of charge, to any person obtaining
#  a copy of this software and associated documentation files (the
#  "Software"), to deal in the Software without restriction, including
#  without limitation the rights to use, copy, modify, merge, publish,
#  distribute, sublicense, and/or sell copies of the Software, and to
#  permit persons to whom the Software is furnished to do so, subject
#  to the following conditions:
#
# The above copyright notice and this permission notice shall be
#  included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
########################################################################

from multiprocessing.managers import BaseManager
from multiprocessing import RLock
from memdb import *

class MemDBConnectProxy(object): pass

class MemDBManager(BaseManager): pass

class MemDBManagerClient:
    MemDBManager.register(‘get_lock‘, callable=lambda: lock)
    MemDBManager.register(‘MemDBConnect‘, callable=lambda: MemDBConnectProxy)

    def __init__(self, servhost, servport, authkey):
        self.config = {
            "host": servhost,
            "port": int(servport),
            "authkey": authkey
        }
        self._lock = None
        self.manager = MemDBManager(address=(self.config[‘host‘], self.config[‘port‘]), authkey=self.config[‘authkey‘])
        self.manager.connect()
        pass

    def __del__(self):
        self.unlock()
        pass

    def lock(self):
        if not self._lock:
            self._lock = self.manager.get_lock()
            self._lock.acquire()
        pass

    def unlock(self):
        if self._lock:
            l = self._lock
            self._lock = None
            l.release()
        pass

    def getMemDBConnect(self):
        self.memdbConn = self.manager.MemDBConnect()
        return self.memdbConn

###########################################################
# start(‘‘, 12345, ‘abc‘)
#
def start(host, port, passkey):
    from memdb_client import MemDBManagerClient

    client = MemDBManagerClient(host, port, passkey)
    print "connect to memdb server success"
    memdbConn = client.getMemDBConnect()

    tables = ["china", "america", "russian"]

    # memdb_server.MemDBConnectProxy
    for t in tables:
        memdbConn.CreateTable(t)
    print memdbConn.QueryTables()

    memdbConn.AddValue("china", "capital", "Beijing")
    memdbConn.AddValue("china", "1-city", "Shanghai")
    memdbConn.AddValue("america", "capital", "Washington")
    memdbConn.AddValue("america", "1-city", "Newyork")
    memdbConn.AddValue("russian", "capital", "Moscow")
    memdbConn.AddValue("russian", "1-city", "Moscow")

    memdbConn.AppendValueListMulti(
        ["china", "america", "russian"],
        ["population", "population", "population"],
        [130000, 30000, 20000],
        [True, True, True])

    for t in tables:
        keys = memdbConn.QueryTableKeys(t)
        for k in keys:
            v = memdbConn.GetValue(t, k, None)
            print "%s: %r=>%r" % (t, k, v)

3 开二个终端，分别启动服务和客户端：

服务端:

Python 2.7.6 (default, Jun 22 2015, 17:58:13)
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import memdb_server
>>> memdb_server.start(‘‘, 12345, ‘abc‘)

客户端:

Python 2.7.6 (default, Jun 22 2015, 17:58:13)
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import memdb_client
>>> memdb_client.start(‘‘, 12345, ‘abc‘)
connect to memdb server success
[‘russian‘, ‘america‘, ‘china‘]
china: ‘1-city‘=>‘Shanghai‘
china: ‘population‘=>[130000]
china: ‘capital‘=>‘Beijing‘
america: ‘1-city‘=>‘Newyork‘
america: ‘population‘=>[30000]
america: ‘capital‘=>‘Washington‘
russian: ‘1-city‘=>‘Moscow‘
russian: ‘population‘=>[20000]
russian: ‘capital‘=>‘Moscow‘
>>>