def thread():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(PARSER_SERVER_ADDR)
except:
prnt("Failed to connect:")
prnt(traceback.format_exc())
wx.CallAfter(failureFunc)
return
stream = ByteStream()
stream.writeByte(pkt.GET_KEY)
stream.writeString(vanityKey)
sock.send(stream.toString())
data = sock.recv(1024)
sock.close()
stream = ByteStream(data)
success = stream.readByte() == 1
if success:
key = stream.readString()
wx.CallAfter(successFunc, key)
else:
wx.CallAfter(failureFunc)
def thread():
global currentKey, raidServer, raidClient
net.node.waitForNS()
# Connect to server...
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(5)
try:
sock.connect(PARSER_SERVER_ADDR)
except:
prnt("Failed to connect:")
prnt(traceback.format_exc())
wx.CallAfter(failureFunc, "connect_failed")
return
# Write data
stream = ByteStream()
stream.writeByte(pkt.JOIN_RAID)
stream.writeByte(VERSION_INT)
stream.writeString(key)
stream.writeString(net.node.getId())
sock.send(stream.toString())
# Read data
data = sock.recv(1024)
stream = ByteStream(data)
# Process data
success = stream.readBoolean()
if success:
currentKey = key
isHost = stream.readBoolean()
serverNode = net.node.getId()
if isHost:
prnt("Raid: Joined raid, became host")
raidServer = RaidServer(sock)
raidServer.start()
else:
prnt("Raid: Joined raid, didn't become host")
serverNode = stream.readString()
sock.close()
raidClient = RaidClient(serverNode, failureFunc, successFunc)
raidClient.start()
else:
reason = stream.readString()
wx.CallAfter(failureFunc, reason)
sock.close()
def recv(self, raw=False):
while len(self.pendingRecv) == 0 and not self.closed:
time.sleep(0.1)
if self.closed:
return None
data = self.pendingRecv.pop(0)
return ByteStream(data) if not raw else data
def __init__(self,filename):
if filename == None:
raise(Exception("Null File Name."))
self.bs = ByteStream(filename)
self._dex = dxlib.dx_parse(self.bs._bs)
def connect(self, targetId, targetPort):
self.waitForNS()
# Prevent connecting if there is already a outbound connection.
if self.getConnection(targetId, targetPort, True):
debug("Duplicate connection to %s:%s found."%(targetId, targetPort))
# Yes, this may throw an error in the app, but they shouldn't
# be creating duplicate connections anyway, so it doesn't matter.
return None
debug("Connecting to %s"%targetId)
out = ByteStream()
out.writeByte(P_CONNECT_REQUEST)
out.writeString(targetId)
out.writeString(targetPort)
self.send(out)
conn = NodeConnection(self, targetId, targetPort, True)
conn.requestTime = time.time()
self.connections.append(conn)
while True:
# Wait till connected.
if conn.state == CS_CONNECTED or conn.state >= CS_FAILED_BASE:
if conn.state == CS_FAILED_NO_NODE:
debug("Failed to connect: no such node")
elif conn.state == CS_FAILED_REJECTED:
debug("Failed to connect: rejected")
break
time.sleep(0.1)
return conn
def run(self):
global PUBLIC_IP_UPDATE_LAST
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind(('', REFLECTION_SERVER_PORT))
debug("Reflection Server listening on %d"%REFLECTION_SERVER_PORT)
refreshPublicIP()
PUBLIC_IP_UPDATE_LAST = time.time()
while True:
r, w, e = select([self.sock], [self.sock], [], 0)
if r:
data, addr = self.sock.recvfrom(1024)
ip = addr[0]
port = addr[1]
if ip == SERVER_GATEWAY_IP:
ip = SERVER_PUBLIC_IP
out = ByteStream()
out.writeString(ip)
out.writeInt(port)
self.sock.sendto(out.toString(), addr)
now = time.time()
if now - PUBLIC_IP_UPDATE_LAST > PUBLIC_IP_UPDATE_INTERVAL:
PUBLIC_IP_UPDATE_LAST = now
threading.Thread(target=refreshPublicIP).start()
time.sleep(0.01)
self.sock.close()
def sendConnectRequest(self, sourceId, targetPort):
""" Sends the connection request from sourceId to this node. """
out = ByteStream()
out.writeByte(P_CONNECT_REQUEST)
out.writeString(sourceId)
out.writeString(targetPort)
self.send(out)
def connectToNodeServer(self):
debug("Connecting to node server @ %s"%repr(self.nodeServer))
while True:
self.updateNodeState(NS_CONNECTING)
if self.sock != None:
self.sock.close()
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sockQueue = net_helpers.SocketQueue(self.sock)
self.sockPacker = net_helpers.Packer()
try:
self.sock.connect(self.nodeServer)
break
except:
debug("Connect failed, trying again in 5s...")
self.updateNodeState(NS_FAILED)
time.sleep(5)
self.updateNodeState(NS_CONNECTED)
debug("Connected.")
# Reset last packet counter so we don't time out.
self.lastPacketReceived = time.time()
# send register packet
debug("Registering with node server...")
b = ByteStream()
b.writeByte(P_REGISTER)
self.send(b)
def test_can_write_one_then_read_as_two():
b = ByteStream()
b.write(b"hello, world")
read = b.read(6)
assert read.tobytes() == b"hello,"
read = b.read(6)
assert read.tobytes() == b" world"
def sendRelayPacket(self, targetId, targetPort, data):
""" Sends tunnel info to a node. """
out = ByteStream()
out.writeByte(P_RELAY_PACKET)
out.writeString(targetId)
out.writeString(targetPort)
out.writeString(data)
self.send(out)
def sendConnectSuccess(self, targetId, targetPort):
""" Sends the connection success packet back to node. """
out = ByteStream()
out.writeByte(P_CONNECT_RESPONSE)
out.writeString(targetId)
out.writeString(targetPort)
out.writeByte(ERR_NO_ERROR)
self.send(out)
def sendConnectFailed(self, targetId, targetPort, errorCode):
""" Sends the connection failed packet back to node. """
out = ByteStream()
out.writeByte(P_CONNECT_RESPONSE)
out.writeString(targetId)
out.writeString(targetPort)
out.writeByte(errorCode)
self.send(out)
def test_distance_only_measured_to_next_matching_byte():
b = ByteStream()
b.write(b"abcabc")
distance = b.until(97)
assert distance == 1
distance = b.until(98)
assert distance == 2
distance = b.until(99)
assert distance == 3
def test_can_resume_reading_after_nothing_available():
b = ByteStream()
b.write(b"hello")
b.read(5)
read = b.read(1)
assert read is None
b.write(b"world")
read = b.read(5)
assert read.tobytes() == b"world"
def test_can_find_bytes():
b = ByteStream()
b.write(b"abc")
distance = b.until(97)
assert distance == 1
distance = b.until(98)
assert distance == 2
distance = b.until(99)
assert distance == 3
def sendTunnelInfo(self, targetId, targetPort, privIp, privPort, pubIp, pubPort):
out = ByteStream()
out.writeByte(P_TUNNEL_INFO)
out.writeString(targetId)
out.writeString(targetPort)
out.writeString(privIp)
out.writeInt(privPort)
out.writeString(pubIp)
out.writeInt(pubPort)
self.send(out)
def reflectAddress(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto('', self.reflectionServer)
privIp, privPort = sock.getsockname()
data = sock.recv(128)
sock.close()
response = ByteStream(data)
pubIp = response.readString()
pubPort = response.readInt()
return (privPort, pubIp, pubPort)
def send(self, data):
if isinstance(data, ByteStream):
data = data.toString()
packet = ByteStream()
packet.writeByte(P_DATA)
packet.writeString(data)
data = packet.toString()
self._send(data)
self.lastPacketSent = time.time()
def test_can_find_bytes_several_chunks_ahead():
b = ByteStream()
b.write(b"xxx")
b.write(b"xxx")
b.write(b"xxx")
b.write(b"abc")
distance = b.until(97)
assert distance == 10
distance = b.until(98)
assert distance == 11
distance = b.until(99)
assert distance == 12
def test_can_write_several_then_read_across_boundaries():
b = ByteStream()
b.write(b"aaa")
b.write(b"bbb")
b.write(b"ccc")
b.write(b"ddd")
read = b.read(4)
assert read.tobytes() == b"aaab"
read = b.read(4)
assert read.tobytes() == b"bbcc"
read = b.read(4)
assert read.tobytes() == b"cddd"
def run(self):
prnt("RaidServer: Booting up...")
self.port = net.node.bind("swap:raid")
self.centralSock.setblocking(False)
while not self.stoppedEvent.isSet():
now = time()
# Central server
r, w, e = select([self.centralSock], [self.centralSock], [], 0)
if r:
data = self.centralSock.recv(1024)
stream = ByteStream(data)
packetType = stream.readByte()
if self.port.connectionPending():
conn = self.port.accept()
self.clientList.append({'conn': conn, 'playerInfo': None})
for client in self.clientList:
conn = client['conn']
if conn.recvPending():
data = conn.recv()
if data == None:
playerName = client['playerInfo']['name'] if client[
'playerInfo'] else "<NoInfo>"
prnt("Client (%s) left raid, reason=%s" %
(playerName, fuzion.formatError(
conn.closedReason)))
self.lastRaidUpdatePoke = time()
self.clientList.remove(client)
continue
packetType = data.readByte()
if packetType == pkt.PLAYER_UPDATE:
self.processPlayerUpdate(client, data)
if now - self.lastRaidUpdateSent > 2 and now - self.lastRaidUpdatePoke < 5:
self.sendRaidUpdate()
self.lastRaidUpdateSent = now
sleep(0.1)
self.port.close()
for client in self.clientList:
conn = client['conn']
conn.close()
self.centralSock.close()
prnt("RaidServer: Shutting down...")
def test_can_measure_how_much_available():
b = ByteStream()
assert b.available() == 0
b.write(b"hello")
assert b.available() == 5
b.read(2)
assert b.available() == 3
b.read(2)
assert b.available() == 1
b.read(2)
assert b.available() == 1
b.read(1)
assert b.available() == 0
def getNewServerNode():
global currentKey, raidServer
# Connect to server...
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(PARSER_SERVER_ADDR)
except:
prnt("Failed to connect:")
prnt(traceback.format_exc())
return
# Write data
stream = ByteStream()
stream.writeByte(pkt.JOIN_RAID)
stream.writeByte(VERSION_INT)
stream.writeString(currentKey)
stream.writeString(net.node.getId())
sock.send(stream.toString())
# Read data
data = sock.recv(1024)
stream = ByteStream(data)
# Process data
success = stream.readBoolean()
if success:
isHost = stream.readBoolean()
serverNode = net.node.getId()
if isHost:
prnt("Raid: Became host")
raidServer = RaidServer(sock)
raidServer.start()
else:
prnt("Raid: Didn't become host")
serverNode = stream.readString()
sock.close()
return serverNode
return None
def setUp(self):
self.HasUri = namedtuple('HasUri', ['uri'])
self.bytestream = ByteStream(chunksize=3)
self.port = '9876'
path = os.path.dirname(__file__)
server = os.path.join(path, 'dummyserver.py')
self.expected = ''.join(uuid4().hex for _ in xrange(100))
devnull = open(os.devnull, 'w')
self.process = subprocess.Popen(
[sys.executable, server, self.port, self.expected],
stdout=devnull,
stderr=devnull)
time.sleep(0.1)
def mainLoop(self):
self.connectToNodeServer()
while True:
now = time.time()
if now - self.lastPacketReceived > NS_KEEPALIVE_TIMEOUT:
debug("Timed out.")
self._disconnected()
continue
r, w, e = select([self.sock], [self.sock], [self.sock], 0)
if r or e:
try:
d = self.sock.recv(2048)
except socket.error as e:
d = None
if e.errno == 10053:
debug("Connection aborted by software, maybe firewall?")
else:
debug("recv() error: errno=%d"%e.errno)
if not d:
self._disconnected()
continue
self.sockPacker.read(d)
self.lastPacketReceived = now
packet = self.sockPacker.popPacket()
if packet:
packet = ByteStream(packet)
self.gotDataFromNodeServer(packet)
if w:
if now - self.lastKeepAliveSent > NS_KEEPALIVE_INTERVAL:
self.lastKeepAliveSent = now
self.send('')
self.sockQueue.processNext()
# Process stale requested connections.
with self.connectionsLock:
for connection in self.connections:
if connection.state == CS_REQUESTED and now - connection.requestTime > 4:
debug("Connection request for %s:%s timed out."%(connection.targetId, connection.targetPort))
connection.state = CS_FAILED_TIMED_OUT
self.connections.remove(connection)
time.sleep(0.001)
self.sock.close()
def closeInternal(self, reason):
with self.closedLock:
if self.closed:
return
if reason == ERR_CLOSED_BY_SELF:
packet = ByteStream()
packet.writeByte(P_CLOSE)
self._send(packet.toString())
self.threadStopped.set()
self.node.connectionDied(self)
self.closed = True
self.closedReason = reason
if not self.loopback and not self.relay:
self.sock.close()
def test_distance_changes_after_read():
b = ByteStream()
b.write(b"abcbca")
distance = b.until(97)
assert distance == 1
distance = b.until(98)
assert distance == 2
distance = b.until(99)
assert distance == 3
b.read(3)
distance = b.until(97)
assert distance == 3
distance = b.until(98)
assert distance == 1
distance = b.until(99)
assert distance == 2
def test_can_accept_chunksize_implementing_int(self):
class SemanticChunksize(object):
THING_SIZE_BYTES = 64
def __init__(self, n_things=10):
self.n_things = n_things
def __int__(self):
return self.n_things * self.THING_SIZE_BYTES
bs = ByteStream(chunksize=SemanticChunksize(n_things=100))
bio = BytesIO()
bio.write(os.urandom(int(1e5)))
bio.seek(0)
chunks = list(bs._process(bio))
self.assertEqual(6400, len(chunks[0]))
def run(self):
while True:
now = time.time()
r, w, e = select([self.sock], [self.sock], [self.sock], 0)
if r or e:
try:
data = self.sock.recv(2048)
except socket.error as e:
debug("%s: .recv() died! errno=%d"%(self.id, e.errno))
break
if not data:
if self.id:
debug("%s: closed"%self.id)
else:
debug("lost unknown connection")
break
self.sockPacker.read(data)
self.lastPacketReceived = now
packet = self.sockPacker.popPacket()
if packet:
packet = ByteStream(packet)
try:
self.handlePacket(packet)
except:
debug("handlePacket crashed.")
debug(traceback.format_exc())
if now - self.lastPacketReceived > KEEPALIVE_TIMEOUT:
debug("%s: timed out."%self.id)
self.sock.close()
break
if w:
if now - self.lastKeepAliveSent > KEEPALIVE_INTERVAL:
self.lastKeepAliveSent = now
self.send('')
self.sockQueue.processNext()
time.sleep(0.01)
self.ns.nodeDied(self.id)
def sendRelay(self, targetId, targetPort, data, fromOutbound):
# Loopback
if self.id == targetId:
# Send it to the opposite connection.
conn = self.getConnection(targetId, targetPort, not fromOutbound)
if conn:
conn.injectRelayRead(data)
else:
debug("sendRelay: Loopback endpoint not found.")
return
if self.nodeState != NS_REGISTERED:
debug("sendRelay: Node not registered. State is %d"%self.nodeState)
return
out = ByteStream()
out.writeByte(P_RELAY_PACKET)
out.writeString(targetId)
out.writeString(targetPort)
out.writeString(data)
self.send(out)
