Python分布式计算（works）

我正在使用一个旧线程发布新代码，试图解决相同的问题。 什么是安全泡菜

短袜

from socket import socket
from socket import AF_INET
from socket import SOCK_STREAM
from socket import gethostbyname
from socket import gethostname

class SocketServer:
  def __init__(self, port):
    self.sock = socket(AF_INET, SOCK_STREAM)
    self.port = port
  def listen(self, data):
    self.sock.bind(("127.0.0.1", self.port))
    self.sock.listen(len(data))
    while data:
      s = self.sock.accept()[0]
      siz, dat = data.pop()
      s.send(siz)
      s.send(dat)
      s.close()

class Socket:
  def __init__(self, host, port):
    self.sock = socket(AF_INET, SOCK_STREAM)
    self.sock.connect((host, port))
  def recv(self, size):
    return self.sock.recv(size)

pack.py

#http://stackoverflow.com/questions/6234586/we-need-to-pickle-any-sort-of-callable
from marshal import dumps as marshal_dumps
from pickle import dumps as pickle_dumps
from struct import pack as struct_pack

class packer:
  def __init__(self):
    self.f = []
  def pack(self, what):
    if type(what) is type(lambda:None):
      self.f = []
      self.f.append(marshal_dumps(what.func_code))
      self.f.append(pickle_dumps(what.func_name))
      self.f.append(pickle_dumps(what.func_defaults))
      self.f.append(pickle_dumps(what.func_closure))
      self.f = pickle_dumps(self.f)
      return (struct_pack('Q', len(self.f)), self.f)

解包

from types import FunctionType
from pickle import loads as pickle_loads
from marshal import loads as marshal_loads
from struct import unpack as struct_unpack
from struct import calcsize

#http://stackoverflow.com/questions/6234586/we-need-to-pickle-any-sort-of-callable

class unpacker:
  def __init__(self):
    self.f = []
    self.fcompiled = lambda:None
    self.sizeofsize = calcsize('Q')
  def unpack(self, sock):
    size = struct_unpack('Q', sock.recv(self.sizeofsize))[0]
    self.f = pickle_loads(sock.recv(size))
    a = marshal_loads(self.f[0])
    b = globals() ##
    c = pickle_loads(self.f[1])
    d = pickle_loads(self.f[2])
    e = pickle_loads(self.f[3])
    self.fcompiled = FunctionType(a, b, c, d, e)
    return self.fcompiled

test.py

from unpack import unpacker
from pack import packer
from sock import SocketServer
from sock import Socket
from threading import Thread
from time import sleep

count = 2
port = 4446

def f():
  print 42

def server():
  ss = SocketServer(port)
  pack = packer()
  functions = [pack.pack(f) for nothing in range(count)]
  ss.listen(functions)

if __name__ == "__main__":
  Thread(target=server).start()
  sleep(1)
  unpack = unpacker()
  for nothing in range(count):
    print unpack.unpack(Socket("127.0.0.1", port))

输出：

<function f at 0x12917d0>
<function f at 0x12915f0>

---

我不认为流程对象设计为通过网络发送。查看multiprocessing/process.py中的第256行

# We subclass bytes to avoid accidental transmission of auth keys over network.

---

听起来我有很好的理由。如果您想进行分布式计算，可能应该研究一个。

值错误：当pickle损坏时，会引发不安全的字符串pickle

。您确定要在一个

sock.recv（）

（unpack.py）中接收整个pickle对象吗

编辑：为了避免这种情况，您可以对任何大小执行（您的

Socket

类必须支持recv，以便使用缓冲区大小参数（即

)):

在接收器程序中：

import struct

length = struct.unpack('Q', sock.recv(struct.calcsize('Q')))[0]
pickled_list = sock.recv(length)

---

“Q”是一个

无符号long

。有关其他struct内容，请参见

是否可以发布一些示例代码来测试脚本？谢谢抛出的错误在哪一行？请记住，函数使用的所有全局变量都应该在

unpack.py

中重新创建。您不应该比较

type（What）is type（lambda:None）

中的类型，而应该是

isinstance（What，types.FunctionType）

。我只能使用本机库。我的第一个选择是绕过该安全措施，因为该实现使用的是专用网络。查看文档，似乎

多处理

是

线程

的克隆，但要跨越不同的进程，以避免全局解释器锁定。我认为你的选择是滚动你自己的分布式计算库，或者让管理层相信开源的重要性非常感谢。缓冲区大小太小。

import struct

struct.pack('Q', len(pickled_list))
# Send it, and then send the pickled list.

import struct

length = struct.unpack('Q', sock.recv(struct.calcsize('Q')))[0]
pickled_list = sock.recv(length)