def __init__(self):
super().__init__()
self.setSocket(1,0, Socket([
None, None,
None, EntranceColor(EntranceColor.PURPLE),
EntranceConnection(), EntranceConnection(),
EntranceColor(EntranceColor.RED), None
]))
self.setSocket(0, 1, Socket([
EntranceColor(EntranceColor.YELLOW), None,
EntranceConnection(), EntranceConnection(),
None, EntranceColor(EntranceColor.RED),
None, None
]))
self.setSocket(1, 1, Socket([
EntranceConnection(), EntranceConnection(),
EntranceConnection(), EntranceConnection(),
None, None,
EntranceConnection(), EntranceConnection()
]))
self.setSocket(2, 1, Socket([
None, EntranceColor(EntranceColor.PURPLE),
None, None,
EntranceColor(EntranceColor.YELLOW), None,
EntranceConnection(), EntranceConnection()
]))
def __init__(self):
super().__init__()
self.setSocket(1, 0, Socket([
None, None,
EntranceConnection(), EntranceConnection(),
EntranceConnection(), EntranceConnection(),
EntrancePagoda(), EntranceCountTiles(7)
]))
self.setSocket(2, 0, Socket([
EntranceColor(EntranceColor.RED), None,
None, EntranceColor(EntranceColor.RED),
None, None,
EntranceConnection(), EntranceConnection()
]))
self.setSocket(0, 1, Socket([
None, EntranceCountBridges(1),
EntranceConnection(), EntranceConnection(),
None, None,
None, None
]))
self.setSocket(1, 1, Socket([
EntranceConnection(), EntranceConnection(),
None, None,
None, None,
EntranceConnection(), EntranceConnection()
]))
def main():
port = 30000
print("Creating socket on port {}".format(port))
socket = Socket()
if not socket.open(port):
print("Failed to open socket")
return
while 1:
data = 'Hello world'
socket.send(Address(a=127,b=0,c=0,d=1,port=port), data, len(data))
while 1:
bytes_read, sender = socket.receive(1024)
if not bytes_read:
break
print(sender)
print("Received packet from {} ({} bytes)".format(
sender.address,
sender.port, bytes_read))
time.sleep(0.25)
def __init__(self, nick, serverAddr, recvMessageCallback, newClientCallback, handshakeDoneCallback, errorCallback):
self.clients = {}
self.nick = nick
self.sock = Socket(serverAddr)
self.recvMessageCallback = recvMessageCallback
self.newClientCallback = newClientCallback
self.handshakeDoneCallback = handshakeDoneCallback
self.errorCallback = errorCallback
self.sendThread = SendThread(self.sock, self.errorCallback)
self.recvThread = RecvThread(self.sock, self.recvMessage, self.errorCallback)
self.messageQueue = Queue.Queue()
def __init__(self, protocol_id, timeout):
self._protocol_id = protocol_id
self._timeout = timeout
self._mode = None
self.running = False
self.state = None
self.socket = Socket()
self.address = Address()
self.timeout_accumulator = 0
self.local_sequence_number = 0
self.clear_data()
def __init__(self):
super().__init__()
self.setSocket(0, 0, Socket([
None, None,
None, EntranceCountTiles(2),
EntranceConnection(), EntranceConnection(),
None, EntrancePagoda()
]))
self.setSocket(0, 1, Socket([
EntranceConnection(), EntranceConnection(),
None, EntrancePagoda(),
None, None,
None, None
]))
def run(self, ssid=None, passwd=None):
"""OH SNAP HERE COME DATBOI"""
logger.log("Starting DATBOI..")
if (ssid == "" or ssid is None) and (passwd == "" or passwd is None):
return self.VALIDATION_ERRORS["ERR_EMPTY"]
else:
self.ssid = ssid
self.set_status(1)
self.socket = Socket(ssid, passwd, self)
def __init__(self):
super().__init__()
self.setSocket(0, 0, Socket([
None, None,
None, None,
EntranceConnection(), EntranceConnection(),
EntrancePagoda(), None
]))
self.setSocket(2, 0, Socket([
None, None,
None, EntrancePagoda(),
EntranceConnection(), EntranceConnection(),
None, None
]))
self.setSocket(0, 1, Socket([
EntranceConnection(), EntranceConnection(),
EntranceConnection(), EntranceConnection(),
None, None,
None, None
]))
self.setSocket(1, 1, Socket([
None, None,
EntranceConnection(), EntranceConnection(),
EntranceCountBridges(1), EntranceYinYang(),
EntranceConnection(), EntranceConnection()
]))
self.setSocket(2, 1, Socket([
EntranceConnection(), EntranceConnection(),
None, None,
None, EntranceCountBridges(2),
EntranceConnection(), EntranceConnection()
]))
def main():
port = 30000
print("Creating socket on port {}".format(port))
socket = Socket()
if not socket.open(port):
print("Failed to create socket")
return
addresses = get_addresses_from_file('addresses.txt')
while 1:
data = 'Hello world'
for address in addresses:
socket.send(address, data, len(data))
while 1:
bytes_read, sender = socket.receive(1024)
if not bytes_read:
break
print("Received packet from {}.{}.{}.{} ({} bytes)".format(
sender.a, sender.b, sender.c, sender.d, len(bytes_read)))
time.sleep(0.5)
def main():
port = 30000
print("Creating socket on port {}".format(port))
socket = Socket()
if not socket.open(port):
print("Failed to create socket")
return
addresses = get_addresses_from_file('addresses.txt')
while 1:
data = 'Hello world'
for address in addresses:
socket.send(address, data, len(data))
while 1:
bytes_read, sender = socket.receive(1024)
if not bytes_read:
break
print("Received packet from {}.{}.{}.{} ({} bytes)".format(
sender.a, sender.b, sender.c, sender.d, len(bytes_read)))
time.sleep(0.5)
def main():
port = 30000
print("Creating socket on port {}".format(port))
socket = Socket()
if not socket.open(port):
print("Failed to open socket")
return
while 1:
data = 'Hello world'
socket.send(Address(a=127, b=0, c=0, d=1, port=port), data, len(data))
while 1:
bytes_read, sender = socket.receive(1024)
if not bytes_read:
break
print(sender)
print("Received packet from {} ({} bytes)".format(
sender.address, sender.port, bytes_read))
time.sleep(0.25)
class ConnectionManager(object):
def __init__(self, nick, serverAddr, recvMessageCallback,
newClientCallback, handshakeDoneCallback, smpRequestCallback,
errorCallback):
self.clients = {}
self.nick = nick
self.sock = Socket(serverAddr)
self.recvMessageCallback = recvMessageCallback
self.newClientCallback = newClientCallback
self.handshakeDoneCallback = handshakeDoneCallback
self.smpRequestCallback = smpRequestCallback
self.errorCallback = errorCallback
self.sendThread = SendThread(self.sock, self.errorCallback)
self.recvThread = RecvThread(self.sock, self.recvMessage,
self.errorCallback)
self.messageQueue = Queue.Queue()
def connectToServer(self):
self.sock.connect()
self.sendThread.start()
self.recvThread.start()
self.__sendProtocolVersion()
self.__registerNick()
def disconnectFromServer(self):
if self.sock.isConnected:
try:
# Send the end command to all clients
for nick, client in self.clients.iteritems():
client.disconnect()
# Send the end command to the server
self.__sendServerCommand(constants.COMMAND_END)
except Exception:
pass
def openChat(self, destNick):
self.__createClient(destNick.lower(), initiateHandshakeOnStart=True)
def __createClient(self, nick, initiateHandshakeOnStart=False):
if type(nick) is not str:
raise TypeError
# Check that we're not connecting to ourself
elif nick == self.nick:
self.errorCallback(nick, errors.ERR_SELF_CONNECT)
return
# Check if a connection to the nick already exists
elif nick in self.clients:
self.errorCallback(nick, errors.ERR_ALREADY_CONNECTED)
return
newClient = Client(self, nick, self.sendMessage,
self.recvMessageCallback,
self.handshakeDoneCallback, self.smpRequestCallback,
self.errorCallback, initiateHandshakeOnStart)
self.clients[nick] = newClient
newClient.start()
def closeChat(self, nick):
client = self.getClient(nick)
if client is None:
return
# Send the end command to the client
self.sendMessage(
Message(clientCommand=constants.COMMAND_END, destNick=nick))
# Remove the client from the clients list
self.destroyClient(nick)
def destroyClient(self, nick):
del self.clients[nick]
def getClient(self, nick):
try:
return self.clients[nick]
except KeyError:
return None
def __sendProtocolVersion(self):
self.__sendServerCommand(constants.COMMAND_VERSION,
constants.PROTOCOL_VERSION)
def __registerNick(self):
self.__sendServerCommand(constants.COMMAND_REGISTER)
def __sendServerCommand(self, command, payload=None):
# Send a commend intended for the server, not another client (such as registering a nick)
self.sendThread.messageQueue.put(
Message(serverCommand=command,
sourceNick=self.nick,
payload=payload))
def sendMessage(self, message):
message.serverCommand = constants.COMMAND_RELAY
message.sourceNick = self.nick
self.sendThread.messageQueue.put(message)
def recvMessage(self, message):
command = message.clientCommand
sourceNick = message.sourceNick
# Handle errors/shutdown from the server
if message.serverCommand == constants.COMMAND_ERR:
# If the error was that the nick wasn't found, kill the client trying to connect to that nick
if int(message.error) == errors.ERR_NICK_NOT_FOUND:
try:
del self.clients[str(message.destNick)]
except:
pass
self.errorCallback(message.destNick, int(message.error))
return
elif message.serverCommand == constants.COMMAND_END:
self.errorCallback('', int(message.error))
return
# Send the payload to it's intended client
try:
self.clients[sourceNick].postMessage(message)
except KeyError as ke:
# Create a new client if we haven't seen this client before
if command == constants.COMMAND_HELO:
self.newClientCallback(sourceNick)
else:
self.sendMessage(
Message(clientCommand=constants.COMMAND_ERR,
error=errors.INVALID_COMMAND))
def newClientAccepted(self, nick):
self.__createClient(nick)
def newClientRejected(self, nick):
# If rejected, send the rejected command to the client
self.sendMessage(
Message(clientCommand=constants.COMMAND_REJECT, destNick=nick))
def respondSMP(self, nick, answer):
self.clients[nick].respondSMP(answer)
class Connection(object):
State = {
'Disconnected': 0,
'Listening': 1,
'Connecting': 2,
'ConnectFail': 3,
'Connected': 4,
}
Mode = {
'Client': 1,
'Server': 2,
}
def __init__(self, protocol_id, timeout):
self._protocol_id = protocol_id
self._timeout = timeout
self._mode = None
self.running = False
self.state = None
self.socket = Socket()
self.address = Address()
self.timeout_accumulator = 0
self.local_sequence_number = 0
self.clear_data()
def start(self, port):
assert (not self.running)
print("Starting connection on port {}".format(port))
if not self.socket.open(port):
return False
self.running = True
return True
def stop(self):
assert self.running
print("Stop connection")
self.clear_data()
self.socket.close()
self.running = False
def listen(self):
print("Server listening for connection")
self.clear_data()
self._mode = self.Mode['Server']
self.state = self.State['Listening']
def connect(self, address):
print("client connection to {}.{}.{}.{}:{}".format(address.a, address.b, address.c, address.d, address.port))
self.clear_data()
self._mode = self.Mode['Client']
self.state = self.State['Connecting']
self.address = address
def is_connecting(self):
return self.state == self.State['Connecting']
def connect_failed(self):
return self.state == self.State['ConnectFail']
def is_connected(self):
return self.state == self.State['Connected']
def is_listening(self):
return self.state == self.State['Listening']
@property
def mode(self):
return self._mode
def update(self, delta_time):
assert self.running
self.timeout_accumulator += delta_time
if self.timeout_accumulator > self._timeout:
if self.state == self.State['Connecting']:
print("Connection timed out")
self.clear_data()
self.state = self.State['ConnectFail']
elif self.state == self.State['Connected']:
print("Connection timed out")
self.clear_data()
if self.state == self.State['Connecting']:
self.state = self.State['ConnectFail']
def send_packet(self, data):
assert self.running
if self.address.address == 0:
return False
packet = [0] * (4 + len(data))
packet[0] = self._protocol_id >> 24
packet[1] = (self._protocol_id >> 16) & 0xFF
packet[2] = (self._protocol_id >> 8) & 0xFF
packet[3] = self._protocol_id & 0xFF
packet[4:] = data[:]
return self.socket.send(self.address, packet), packet
def receive_packet(self, size):
assert self.running
bytes_read, sender = self.socket.receive(size + 4)
if not bytes_read or len(bytes_read) <= 4:
return 0, []
if (bytes_read[0] != self._protocol_id >> 24 or
bytes_read[1] != ((self._protocol_id >> 16) & 0xFF) or
bytes_read[2] != ((self._protocol_id >> 8) & 0xFF) or
bytes_read[3] != (self._protocol_id & 0xFF)):
return 0, []
if self._mode == self.Mode['Server'] and not self.is_connected():
print("Server accepts connection from client {}:{}".format(sender.address, sender.port))
self.state = self.State['Connected']
self.address = sender
if sender == self.address:
if self._mode == self.Mode['Client'] and self.state == self.State['Connecting']:
print("Client completes connection with server")
self.state = self.State['Connected']
self.timeout_accumulator = 0
return size - 4, bytes_read[4:]
return 0, []
def clear_data(self):
self.state = self.State['Disconnected']
self.timeout_accumulator = 0
self.address = Address()
self.local_sequence_number = 0
class ConnectionManager(object):
def __init__(self, nick, serverAddr, recvMessageCallback, newClientCallback, handshakeDoneCallback, smpRequestCallback, errorCallback):
self.clients = {}
self.nick = nick
self.sock = Socket(serverAddr)
self.recvMessageCallback = recvMessageCallback
self.newClientCallback = newClientCallback
self.handshakeDoneCallback = handshakeDoneCallback
self.smpRequestCallback = smpRequestCallback
self.errorCallback = errorCallback
self.sendThread = SendThread(self.sock, self.errorCallback)
self.recvThread = RecvThread(self.sock, self.recvMessage, self.errorCallback)
self.messageQueue = Queue.Queue()
def connectToServer(self):
self.sock.connect()
self.sendThread.start()
self.recvThread.start()
self.__sendProtocolVersion()
self.__registerNick()
def disconnectFromServer(self):
if self.sock.isConnected:
try:
# Send the end command to all clients
for nick, client in self.clients.iteritems():
client.disconnect()
# Send the end command to the server
self.__sendServerCommand(constants.COMMAND_END)
except Exception:
pass
def openChat(self, destNick):
self.__createClient(destNick.lower(), initiateHandshakeOnStart=True)
def __createClient(self, nick, initiateHandshakeOnStart=False):
if type(nick) is not str:
raise TypeError
# Check that we're not connecting to ourself
elif nick == self.nick:
self.errorCallback(nick, errors.ERR_SELF_CONNECT)
return
# Check if a connection to the nick already exists
elif nick in self.clients:
self.errorCallback(nick, errors.ERR_ALREADY_CONNECTED)
return
newClient = Client(self, nick, self.sendMessage, self.recvMessageCallback, self.handshakeDoneCallback, self.smpRequestCallback, self.errorCallback, initiateHandshakeOnStart)
self.clients[nick] = newClient
newClient.start()
def closeChat(self, nick):
client = self.getClient(nick)
if client is None:
return
# Send the end command to the client
self.sendMessage(Message(clientCommand=constants.COMMAND_END, destNick=nick))
# Remove the client from the clients list
self.destroyClient(nick)
def destroyClient(self, nick):
del self.clients[nick]
def getClient(self, nick):
try:
return self.clients[nick]
except KeyError:
return None
def __sendProtocolVersion(self):
self.__sendServerCommand(constants.COMMAND_VERSION, constants.PROTOCOL_VERSION)
def __registerNick(self):
self.__sendServerCommand(constants.COMMAND_REGISTER)
def __sendServerCommand(self, command, payload=None):
# Send a commend intended for the server, not another client (such as registering a nick)
self.sendThread.messageQueue.put(Message(serverCommand=command, sourceNick=self.nick, payload=payload))
def sendMessage(self, message):
message.serverCommand = constants.COMMAND_RELAY
message.sourceNick = self.nick
self.sendThread.messageQueue.put(message)
def recvMessage(self, message):
command = message.clientCommand
sourceNick = message.sourceNick
# Handle errors/shutdown from the server
if message.serverCommand == constants.COMMAND_ERR:
# If the error was that the nick wasn't found, kill the client trying to connect to that nick
if int(message.error) == errors.ERR_NICK_NOT_FOUND:
try:
del self.clients[str(message.destNick)]
except:
pass
self.errorCallback(message.destNick, int(message.error))
return
elif message.serverCommand == constants.COMMAND_END:
self.errorCallback('', int(message.error))
return
# Send the payload to it's intended client
try:
self.clients[sourceNick].postMessage(message)
except KeyError as ke:
# Create a new client if we haven't seen this client before
if command == constants.COMMAND_HELO:
self.newClientCallback(sourceNick)
else:
self.sendMessage(Message(clientCommand=constants.COMMAND_ERR, error=errors.INVALID_COMMAND))
def newClientAccepted(self, nick):
self.__createClient(nick)
def newClientRejected(self, nick):
# If rejected, send the rejected command to the client
self.sendMessage(Message(clientCommand=constants.COMMAND_REJECT, destNick=nick))
def respondSMP(self, nick, answer):
self.clients[nick].respondSMP(answer)
import sys
import optparse
import pickle
import h5py
usage = '%prog <save/load> filename'
parser = optparse.OptionParser(usage)
options, args = parser.parse_args()
if len(args) < 2:
sys.exit(parser.format_help())
import setup
from sock import Socket
scope = Socket(setup.scope_ip, timeout=20.0)
scope.clear()
if args[0] == 'save':
settings = get_settings(scope)
for command, setting in settings.items():
print('%s, %s' % (command, setting))
f = open(args[1], 'wb')
pickle.dump(settings, f)
f.close()
elif args[0] == 'load':
try:
f = h5py.File(args[1], 'r')
settings = dict(f.attrs)
f.close()
except h5py.h5e.LowLevelIOError:
