数据库内核
"""
"""
import socket
import pickle

_cache = {}

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
host = "127.0.0.1"
port = 58624
s.bind((host, port))
s.listen(5)

# 数据库引擎
while True:
# TODO 缺少日志功能
print("开始等待连接.......{}".format((host, port)))
sock, address = s.accept()
print("连接成功{address}......".format(address=address))

while True:
"""等待发送者发送数据"""
recv_value = sock.recv(1024)

try:
"""将发送者发送的数据反序列化成字典对象"""
recv_dict = pickle.loads(recv_value)
except:
# TODO 抛出准确的异常信息
print(
"反序列化失败, revc_dict={recv_dict}".format(recv_dict=recv_dict))
continue

try:
if recv_dict['method'] == "get":
"""获取数据"""
result = _cache.get(recv_dict['data'])
result = pickle.dumps(result)
print("获取到数据 : {key}:{value}".format(
key=recv_dict['data'],
value=_cache.get(recv_dict['data'])))
sock.send(result)
elif recv_dict['method'] == "set":
"""插入数据"""
result = recv_dict['data']
result = result.split(":")
print("已插入数据: {}".format(result))
_cache[result[0]] = result[1]
elif recv_dict['method'] == "delete":
"""删除数据"""
result = recv_dict['data']
print("已删除数据, key={}, value={}".format(
result, _cache[result]))
del _cache[result]
elif recv_dict['method'] == "command":
if recv_dict['data'] == "close":
"""关闭连接"""
sock.close()
break
if recv_dict['data'] == "size":
"""获取长度"""
result = len(_cache)
print("获取长度 : {}".format(result))
result = pickle.dumps(result)
sock.send(result)
if recv_dict['data'] == 'dict_all':
"""获取所有数据"""
result = pickle.dumps(_cache)
print("获取所有数据: {}".format(_cache))
sock.send(result)
else:
print(
"查询参数有误， revc_dict={recv_dict}".format(
recv_dict=recv_dict))
except:
# TODO 抛出准确的异常
print(
"查询参数异常， revc_dict={recv_dict}".format(recv_dict=recv_dict))
continue

数据库驱动
import socket
import pickle

"""
obj.get("key") value 驱动层面对其反序列化后返回给调用者
obj.set("key : value") 有错返回异常字符串
obj.delete("key")

obj.commnd("size") 返回总的数据长度
obj.command("close")
obj.commnd("dict_all") 返回所有数据的字典形式

{
"data": ....,
"method": "get" or "set" or "delete or" "commnd"
}
"""


class KVDBDrive:
"""
数据库驱动
"""

def __init__(self, host="127.0.0.1", port=9090):
try:
self.s = socket.socket()
self.s.connect((host, port))
except:
print("socket建立失败. {}".format((host, port)))

def __enter__(self):
return self

def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
return True

def get(self, key):
"""
将key序列化后发送给数据库引擎
接收到数据库引擎返回值后反序列化，并返回给调用者
"""
if key:
query = {"method": "get", "data": key}
query = pickle.dumps(query)
self.s.send(query)

result = self.s.recv(1024)
result = pickle.loads(result)
if result:
return result

def set(self, statement):
# statement = statement.split(":")
if statement:
query = {"method": "set", "data": statement}
query = pickle.dumps(query)
self.s.send(query)

# result = self.s.recv(1024)
# result = pickle.loads(result)
# return result

def close(self):
query = {"method": "command", "data": "close"}
query = pickle.dumps(query)
self.s.send(query)