def kickout(self, user_data):
fd = user_data["fd"]
if user_data.has_key("uuid"):
GM().getPlayerMgr().delPlayer(user_data["uuid"])
if self.user_map.has_key(self.fd_to_socket[fd]):
del self.user_map[self.fd_to_socket[fd]]
GM().getLogMgr().logD("连接关闭")
self.epl.unregister(fd)
self.fd_to_socket[fd].close()
del self.fd_to_socket[fd]
def protocol7(first_number, second_number):
start = time.perf_counter()
n, public_key, private_key = paillierself.generate_paillier_keypair()
p, q, R = 232312311797, 971179711797, 17
alice = GM.Alice(p, q, R)
bob = GM.Bob(R, p * q)
l = 40
a = first_number
b = second_number
aa = public_key.encrypt(a)
print("明文a的密文：" + str(public_key.raw_encrypt(a)))
bb = public_key.encrypt(b)
print("明文b的密文：" + str(public_key.raw_encrypt(b)))
xx = ((2**l) + bb - aa)
x = private_key.decrypt(xx)
r = random.randint(1, 2**(l + 20))
rr = public_key.encrypt(r)
zz = (xx + rr)
z = private_key.decrypt(zz)
c = r % (2**l)
d = z % (2**l)
dgk_number = dgk.dgk(d, c, public_key, private_key)
if dgk_number:
t1 = "1"
else:
t1 = "0"
t11 = bob.Ec(t1) # t11 = [ t']
r_int = int(r / (2**l))
r_int = r_int % 2
if r_int:
r1 = "1"
else:
r1 = "0"
r11 = bob.Ec(r1) # r11 = [rl]
z_int = int(z / (2**l))
z_int = z_int % 2
if z_int:
z1 = "1"
else:
z1 = "0"
z11 = bob.Ec(z1) # z11 = [zl]
temp = GM.testTong(z11, r11, p * q)
tt = GM.testTong(temp, t11, p * q)
t = alice.Dc(tt)
end = time.perf_counter()
print("运行时间：" + str(end - start) + "秒")
#print("x:" + str(x), "r:" + str(r), "z:" + str(z), "c:" + str(c),"d:" + str(d))
#print("t1:" +str(t1),"r1:"+str(r1),"z1:"+str(z1),t)
return t
def __init__(self, host, port, timeout, msgHandler):
self._msgHandler = msgHandler
# 创建服务端socket
self.server_sock = socket(AF_INET, SOCK_STREAM)
# 设置地址复用
self.server_sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
# 绑定IP地址
self.server_sock.bind((host, port))
# 监听，并设置监听队列长度
self.server_sock.listen(10)
GM().getLogMgr().logI("服务器socket初始化完成，监听IP：" + host + ":" + str(port))
# 设置服务端socket为非阻塞方式
self.server_sock.setblocking(False)
# 超时时间
self.timeout = timeout
self.epl = epoll()
# 注册服务器监听fd到等待读事件集合
self.epl.register(self.server_sock.fileno(), EPOLLIN)
# 保存客户端消息的字典
self.user_map = {}
# 文件句柄到所对应套接字对象的字典,格式为{句柄：对象}
self.fd_to_socket = {self.server_sock.fileno(): self.server_sock}
self.runFlag = True
def onReconnectReq(self, user_data):
GM().getLogMgr().logD("收到重新连接消息")
req = Request()
req.ParseFromString(user_data["msg_data"])
res = Response()
if req.HasField("reconnectReq"):
if GM().getPlayerMgr().reconnect(req.reconnectReq.uuid, user_data):
GM().getLogMgr().logD("onReconnectReq()")
res.result = True
else:
res.result = False
res.errorDescribe = "the player if off line, can't reconnect!"
else:
res.result = False
res.errorDescribe = "wrong reconnect message!"
res.lastResponse = True
res_str = res.SerializeToString()
self.sendMsg(user_data, Reconnect_Res, res_str)
def protocol7(first_number,second_number,public_key, private_key):
p, q, R = 232312311797, 971179711797, 17
alice = GM.Alice(p, q, R)
bob = GM.Bob(R, p * q)
l=40
a=first_number
b=second_number
aa = public_key.encrypt(a)
bb = public_key.encrypt(b)
xx = ((2 ** l) + bb - aa)
x = private_key.decrypt(xx)
r = random.randint(1, 2 ** (l+20))
rr = public_key.encrypt(r)
zz = (xx + rr)
z = private_key.decrypt(zz)
c = r % (2 ** l)
d = z % (2 ** l)
dgk_number = dgk.dgk(d,c,public_key, private_key)
if dgk_number:
t1 = "1"
else:
t1 = "0"
t11 = bob.Ec(t1) # t11 = [ t']
r_int = int(r / (2 ** l))
r_int = r_int % 2
if r_int :
r1 = "1"
else :
r1 = "0"
r11 = bob.Ec(r1) # r11 = [rl]
z_int = int(z / (2 ** l))
z_int = z_int % 2
if z_int :
z1 = "1"
else :
z1 = "0"
z11 = bob.Ec(z1) # z11 = [zl]
temp = GM.testTong( z11,r11,p * q)
tt = GM.testTong(temp, t11,p * q)
t = alice.Dc(tt)
#print("x:" + str(x), "r:" + str(r), "z:" + str(z), "c:" + str(c),"d:" + str(d))
#print("t1:" +str(t1),"r1:"+str(r1),"z1:"+str(z1),t)
return t
def procMsg(self, user_data):
if user_data["msg_id"] == Register_Req:
self.onRegisterReq(user_data)
elif user_data["msg_id"] == Login_Req:
self.onLoginReq(user_data)
elif user_data["msg_id"] == Reconnect_Req:
self.onReconnectReq(user_data)
elif user_data["msg_id"] == Route_Msg:
self.onRouteMsg(user_data)
else:
GM().getLogMgr().logD("No function to response msg.(msgid=" +
str(msg_id) + ")")
def FoF_full(Ra,Dec,v,clean_faux = False):
FoF(Ra,Dec,v,Vel_Limit,projected_limit,'run_results.txt')
f=open('run_results.txt') #open the text file
lines=f.readlines() #make a list of each row (which is a string)
f.close()
run_results = [np.array([int(x) for x in line.split()]) for line in lines]
### Graph theory time #####
groups,edges,weighting,weighting_normed,sub_groupings=GM.Stabalize(run_results,cutoff,runs)
if clean_faux == True:
groups,sub_groupings = Clean_Bad_Groups(Ra,Dec,v,groups,sub_groupings,weighting_normed)
notgroups=np.setdiff1d(np.arange(0,len(Ra)),np.concatenate(groups))
return groups,edges,weighting,weighting_normed,sub_groupings,notgroups
def onLoginReq(self, user_data):
GM().getLogMgr().logD("收到登陆消息")
req = Request()
req.ParseFromString(user_data["msg_data"])
res = Response()
if req.HasField("loginReq"):
if GM().getPlayerMgr().login(req.loginReq.uuid, user_data):
GM().getLogMgr().logD("登陆成功")
res.result = True
res.lastResponse = True
res_str = res.SerializeToString()
self.sendMsg(user_data, Login_Res, res_str)
else:
GM().getLogMgr().logD("无法登陆")
res.result = False
res.lastResponse = True
res.errorDescribe = "用户不存在"
else:
res.result = False
res.lastResponse = True
res.errorDescribe = "wrong login message!"
res_str = res.SerializeToString()
self.sendMsg(user_data, Login_Res, res_str)
def __init__(self, config):
GM().setServer(self)
self._host = config["host"]
self._port = config["port"]
self._timeout = config["timeout"]
# 创建消息分发器
self._msgHandler = MsgHandler()
# 向消息分发器注册消息处理模块
baseModule = BaseModule(0x00010000)
self._msgHandler.registerModule(baseModule)
# 初始化网络并监听
self._net = Net(self._host, self._port, self._timeout,
self._msgHandler)
def onRouteMsg(self, user_data):
GM().getLogMgr().logD("收到转发消息")
player = GM().getPlayerMgr().getOnlinePlayer(user_data["uuid"])
if player is not None:
room = player.getRoom()
if room is not None:
if player.getRoomPos() is True:
peerPlayer = room.getPlayer2()
else:
peerPlayer = room.getPlayer1()
if peerPlayer is not None:
peerPlayer.sendMsg(user_data["msg_id"],
user_data["msg_data"])
else:
GM().getLogMgr().logD("对手不存在，无法转发消息")
else:
GM().getLogMgr().logD("玩家没有在房间中，无法转发消息")
else:
GM().getLogMgr().logD("玩家尚未登录")
def onRegisterReq(self, user_data):
GM().getLogMgr().logD("收到注册消息")
req = Request()
req.ParseFromString(user_data["msg_data"])
if req.HasField("registerReq"):
GM().getLogMgr().logD("onRegisterReq()")
player = GM().getPlayerMgr().createPlayer(user_data)
res = Response()
res.result = True
res.lastResponse = True
res.registerRes.uuid = player.getUuid()
res.registerRes.name = player.getName()
res_str = res.SerializeToString()
self.sendMsg(user_data, Register_Res, res_str)
def myfun(myg, mya, myb, myG, myn, mysteps, mylambda, mydelta):
mys=GM.gmImpulse(gamma=myg,alpha=mya,beta=myb, \
xinit=xinit, G=myG, \
duration=duration,n=myn, \
nsteps=mysteps,lambdaval=mylambda,deltaval=mydelta)
return (mys)
def usr1Handler(signo, frame):
global server
GM().getLogMgr().logI("进程关闭")
server.stop()
def run(self):
self._net.run()
def stop(self):
self._net.stop()
def getNet(self):
return self._net
if __name__ == "__main__":
global server
pidfile = "../proc/pid"
if path.exists(pidfile):
GM().getLogMgr().logE("pid文件已经存在，请检查程序是否已经运行")
else:
f = file(pidfile, "w")
f.write(str(getpid()))
f.close()
config = {}
config["host"] = "115.29.53.18"
config["port"] = 8888
config["timeout"] = 10
server = Server(config)
signal(SIGUSR1, usr1Handler)
server.run()
if path.exists(pidfile):
fig.text(-0.02, 0.87, 'a)', fontdict=fontdict) fig.text(0.49, 0.87, 'b)', fontdict=fontdict) fig.savefig(os.path.join(sdir, 'w_filt_example.pdf'), bbox_inches='tight', pad_inches=0) # %% Vertical spectra of shear Float = E77 hpids = np.arange(200, 210) dz = 1. z = np.arange(-1400, -200, dz) N = 2e-3 f = 1.2e-4 IW = GM.GM(N, f, Ef=6., **GM.GM76) __, __, u = E77.get_interp_grid(hpids, z, 'zef', 'U_abs') __, __, v = E77.get_interp_grid(hpids, z, 'zef', 'V_abs') m, Su = sig.periodogram(u, fs=1./dz, window='hanning', axis=0) __, Sv = sig.periodogram(v, fs=1./dz, window='hanning', axis=0) use = m < 1./8. m, Su, Sv = m[use], Su[use, :], Sv[use, :] Stot = Su + Sv Ssh = (m**2 * Stot.T/(N/(np.pi*2))**2).T
def run(self):
t1 = time.time()
while self.runFlag:
try:
events = self.epl.poll(self.timeout)
if not events:
continue
except:
continue
for fd, event in events:
sock = self.fd_to_socket[fd]
# 如果活动socket为当前服务socket，表示有新的连接
if sock == self.server_sock:
conn, addr = self.server_sock.accept()
GM().getLogMgr().logD("新连接:" + str(addr))
# 新的socket设置为非阻塞
conn.setblocking(False)
# 注册新连接fd到待读事件集合
self.epl.register(conn.fileno(), EPOLLIN)
# 把新连接的文件句柄保存到字典
self.fd_to_socket[conn.fileno()] = conn
# 以新连接的对象为键值，值存储在队列中，保存每个连接的信息
user_data = {}
user_data["fd"] = conn.fileno()
user_data["rbuf"] = ""
user_data["wbuf"] = ""
user_data["epl"] = self.epl
self.user_map[conn] = user_data
# 关闭事件
elif event & EPOLLHUP:
user_data = self.user_map[self.fd_to_socket[fd]]
self.kickout(user_data)
# 可读事件
elif event & EPOLLIN:
# 接收数据
data = sock.recv(1024)
if data:
GM().getLogMgr().logD("收到数据,客户端:" +
str(sock.getpeername()))
self.user_map[sock]["rbuf"] += data
bufdata = self.user_map[sock]["rbuf"]
while len(bufdata) >= 8:
msg_id = struct.unpack('!I', bufdata[0:4])[0]
data_len = struct.unpack('!I', bufdata[4:8])[0]
if len(bufdata) >= data_len:
packet_data = bufdata[8:data_len]
self.user_map[sock]["rbuf"] = bufdata[
data_len:]
bufdata = self.user_map[sock]["rbuf"]
user_data = self.user_map[sock]
user_data["msg_id"] = msg_id
user_data["msg_data"] = packet_data
self._msgHandler.handleMsg(user_data)
else:
break
else:
GM().getLogMgr().logD("连接关闭，客户端：" +
str(sock.getpeername()))
self.epl.unregister(fd)
self.user_map.pop(sock)
sock.close()
del self.fd_to_socket[fd]
# 可写事件
elif event & EPOLLOUT:
if len(self.user_map[sock]["wbuf"]) > 0:
sock.send(self.user_map[sock]["wbuf"])
self.user_map[sock]["wbuf"] = ""
GM().getLogMgr().logD("发送数据,客户端:" +
str(sock.getpeername()))
else:
self.epl.modify(fd, EPOLLIN)
t2 = time.time()
delta = t2 - t1
t1 = t2
# 定时器管理类步进
GM().getTimerMgr().step(delta)
for fd in self.fd_to_socket:
self.epl.unregister(fd)
self.fd_to_socket[fd].close()
self.epl.close()
with open(file, 'w', encoding='utf8') as player_data:
json.dump(player_dict, player_data, cls=PlayerDecoder)
except AttributeError:
raise AttributeError("Unkown argument in put_player_db")
except FileNotFoundError:
raise FileNotFoundError(f"2b JSON file {file} not found")
# Parse the json config file
config = get("game_config.json")
db = get_player_db("db.json")
# Create Bot
bot = discord.Client()
print("here")
manager = GM.GM(bot, config, db)
print(manager.bot_text)
perms = servermanager.ServerManager(bot)
holder = IHoldThings()
@bot.event
async def on_ready():
print(type(manager.client))
holder.messMan = messagemanager.MessageManager(bot)
# A list of all servers the bot is a part of
manager.joined_servers = manager.client.servers
# This loops checks every member it sees in
# every server. First it checks if the member
# user id is in the owners list in the config
m *= 2. * np.pi
ax.loglog(m, Pzs, color='grey', linewidth=2., alpha=0.01, label=None)
ax.loglog(m,
np.median(Pzs, axis=-1),
'-k',
linewidth=2.,
alpha=1,
label=label)
# Set up GM spectrum
N = 2.2e-3
f = -1.23e-4
#IWF = GM.GM(N, f)
#GMw = IWF.Sm(m/(2.*np.pi), 'vert_vel')
GMw2 = GM.E_VKE(m, f, N, b_=1000)
ax.loglog(m, GMw2, '--k', linewidth=2., label='GM')
#ax.loglog(m, GMw2, '--r', linewidth=2., label='GM2')
ax.legend(loc=0)
ax.set_xlim(3e-3, .5)
ax.set_ylim(1e-7, 1e-1)
ax.set_ylabel(
'Vertical kinetic energy density (m$^{2}$ s$^{-2}$ (rad m$^{-1}$)$^{-1}$)')
ax.set_xlabel('Vertical wavenumber (rad m$^{-1}$)')
pf.my_savefig(fig,
'both',
'w_spec_GM',
sdir,
f.write('\n')
f.close()
#Reading in the results of the numerous runs and putting them back into a list of arrays to be used for the graph theory
f = open('run_results.txt') #open the text file
lines = f.readlines() #make a list of each row (which is a string)
run_results = []
for i in range(len(lines)):
run_results.append(
np.array([int(x) for x in lines[i].split()])
) #make the array of our list which splits each string into a list of integers (galaxy labels)
#done reading in
####
groups, edges, weighting, weighting_normed, sub_groupings = GM.Stabalize(
run_results, 0.5, runs)
notgroups = np.setdiff1d(np.arange(0, len(Ra)), np.concatenate(groups))
end_time = datetime.datetime.now()
print 'Program Time:', end_time - start_time
print
print 'Writing to File'
prefix_string = '2MRS'
#Write edge metadata to a file quickly (May want to move this into a proper place )
edge_1, edge_2, weight = np.zeros(len(edges)), np.zeros(len(edges)), np.zeros(
len(edges)) #split the edges tuples triplates into 3 different arrays
for i in range(len(edges)):
edge_1[i] = edges[i][0]
edge_2[i] = edges[i][1]
weight[i] = edges[i][2]