def run(self):
# Initiate the connection to the server
self.connection.connect((self.host, self.port))
self.connected = True
self.msg_parser = MessageParser()
self.msg_receiver = MessageReceiver(self, self.connection)
self.msg_receiver.start()
while self.connected:
inp = raw_input("command <content>:\n").split()
command = inp[0]
if command not in legal_requests:
print("please type a legal command")
continue
content = None
if command == 'login' or command == 'msg':
if len(inp) <= 1:
print("please type <content>")
continue
content = " ".join(inp[1:])
data = {
'request': command,
'content': content}
self.send_payload(json.dumps(data))
self.msg_receiver.join()
def run(self):
MsgParser = MessageParser()
while True:
data = (self.connection.recv(8192)).decode()
if data:
MsgParser.parse(data)
pass
def run(self):
# Initiate the connection to the server
self.connection.connect((self.host, self.server_port))
self.receiver = MessageReceiver(self, self.connection)
self.MessagePars = MessageParser()
while True:
input_ = raw_input().split(' ')
if len(input_) != 0:
if (input_[0] == "login"):
self.send_payload({
'request': 'login',
'content': input_[1]
})
elif (input_[0] == "logout"):
self.send_payload({
'request': 'logout',
})
elif (input_[0] == "msg"):
self.send_payload({'request': 'msg', 'content': input_[1]})
elif (input_[0] == "names"):
self.send_payload({'request': 'names'})
elif (input_[0] == "help"):
self.send_payload({'request': 'help'})
else:
print "Error, type 'help'"
def __init__(self, name, praw_reddit, triggers, username):
self.name = name
self.praw_reddit = praw_reddit
self.triggers = triggers
self.username = username
self.already_done = []
self.msg_parser = MessageParser(triggers)
def __init__(self, client, connection):
super(MessageReceiver, self).__init__()
#self.thread = Thread(target=self.run)
self.daemon = True
self.client = client
self.connection = connection
self.msgParser = MessageParser()
class MessageReceiver(Thread):
"""
This is the message receiver class. The class inherits Thread, something that
is necessary to make the MessageReceiver start a new thread, and it allows
the chat client to both send and receive messages at the same time
"""
def __init__(self, client, connection):
"""
This method is executed when creating a new MessageReceiver object
"""
# Flag to run thread as a deamon
#self.client=client
self.connection = connection
# tODO: Finish initialization of MessageReceiver
super(MessageReceiver,self).__init__()
def run(self):
# tODO: Make MessageReceiver receive and handle payloads
self.MessageParser = MessageParser()
#s_thread = MessageParser(payload)
#s_thread.start()
while True:
payload = self.connection.recv(4096)
#print('We now listening for input from server.' + payload)
self.MessageParser.parse(payload)
class MessageReceiver(Thread):
"""
This is the message receiver class. The class inherits Thread, something that
is necessary to make the MessageReceiver start a new thread, and it allows
the chat client to both send and receive messages at the same time
"""
def __init__(self, client, connection):
super(MessageReceiver, self).__init__()
"""
This method is executed when creating a new MessageReceiver object
"""
# Flag to run thread as a deamon. A deamon is a process that runs in the background.
self.daemon = True
self.parser = MessageParser()
self.client = client
self.connection = connection
self.start()
def run(self):
while True:
received_message = self.connection.recv(4096)
try:
print self.parser.parse(received_message)
except:
pass
def run(self):
# TODO: Make MessageReceiver receive and handle payloads
parser = MessageParser()
while True:
self.received = self.connection.recv(1024) # v2
# print self.received
print parser.parse(self.received)
class Client:
"""
This is the chat client class
"""
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# TODO: Finish init process with necessary code
self.host = host
self.server_port = server_port
self.messageParser = MessageParser()
self.messageReceiver = MessageReceiver(self, self.connection)
self.run()
def run(self):
"""
Main process of the client. Waits for input from user
"""
self.connection.connect((self.host, self.server_port))
self.messageReceiver.start()
print 'Client running...\nType \'quit\' to end or \'help\' for info'
while True:
command = raw_input()
if command == 'quit':
self.disconnect()
print 'Client closing'
break
self.send_payload(self.messageParser.parse_dataToSend(command))
def disconnect(self):
"""
Close sock connection
"""
self.connection.close()
def receive_message(self, message):
"""
Prints received message after it's parsed
"""
print self.messageParser.parse(message)
def send_payload(self, data):
"""
Sends data to server
"""
self.connection.send(data)
def receive_message(self, message):
#Decode message
msg_parser = MessageParser()
#print(message)
#if message is None:
# print('oops its none')
decoded_message = msg_parser.parse(message)
#Print the "handled" response
print(decoded_message)
def __init__(self, client, connection):
"""
This method is executed when creating a new MessageReceiver object
"""
threading.Thread.__init__(self, name=client)
# Flag to run thread as a deamon
self.daemon = True
self.connection = connection
self.parser = MessageParser()
class Client:
"""
This is the chat client class
"""
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
self.host = host
self.server_port = server_port
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Set up messageparser
self.message_parser = MessageParser()
try:
self.run()
except KeyboardInterrupt: # Disconnect on keyboard interupt
self.disconnect()
def run(self):
# Initiate the connection to the server
print 'Connecting to the server..'
self.connection.connect((self.host, self.server_port))
# Initialize a message reciver
reciver = MessageReceiver(self, self.connection)
reciver.start()
# Wait a second for server response
time.sleep(1)
cin = str(raw_input())
while cin != "exit":
temp_dict = cin.partition(' ')
payload = {"request": temp_dict[0], "content": temp_dict[2]}
self.send_payload(json.dumps(payload))
cin = str(raw_input())
self.disconnect()
def disconnect(self):
print "Closing connection..."
# Make sure the user is logged out
payload = {"request": "logout", "content": ""}
self.send_payload(json.dumps(payload))
time.sleep(1) # Wait for the logout payload to be sent
self.connection.close()
print "Connection terminated."
def receive_message(self, payload):
print self.message_parser.parse(payload)
def send_payload(self, data):
self.connection.send(data)
def run(self):
# TODO: Make MessageReceiver receive and handle payloads
while True:
message_raw = self.connection.recv(4096) # bit to hardcoded?
if not message_raw:
self.client.disconnect()
print("MessageReceiver received command") # temp
message_parser = MessageParser()
response = message_parser.parse(message_raw)
self.client.print_line(response)
def __init__(self, host, server_port):
"This method is run when creating a new Client object"
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.connection.settimeout(0.1)
# TODO: Finish init process with necessary code
self.host = host
self.server_port = server_port
self.MessageParser = MessageParser()
self.disconnected = False
self.run()
def __init__(self, dispatcher):
""" Juna's brain. Handles messages and tries to make a reply.
"""
self.dispatcher = dispatcher
#Callbacks
self.dispatcher += Event('rcv', self.learn)
self.dispatcher += Event('speak_request', self.getMessageString)
self.parser = MessageParser()
self.postprocessor = Postprocessor()
self.DEBUG = DEBUG
class Client:
"""
This is the chat client class
"""
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
self.serverport = server_port
self.h = host
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.MParser = MessageParser()
self.MReceiver = MessageReceiver(self, self.connection)
self.run()
def run(self):
# Initiate the connection to the server
self.connection.connect((self.h, self.serverport))
self.MReceiver.start()
while True:
userInput = raw_input()
try:
if userInput:
request, content = userInput.split()
if not content:
content = None
payload = {
'request': request,
'content': content
}
self.send_payload(payload)
except KeyboardInterrupt:
self.disconnect()
def handleInput(self, userInput):
message = userInput.split(' ')
def disconnect(self):
self.connection.close()
print "Server disconnected."
def receive_message(self, message):
print self.MParser.parse(message)
def send_payload(self, data):
payload = json.dumps(data)
self.connection.send(payload)
class Client:
"""
This is the chat client class
"""
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.messageParser = MessageParser()
self.host = ""
self.server_port = 9998
# TODO: Finish init process with necessary code
self.run()
self.messageReceiver = MessageReceiver(self,self.connection)
self.messageReceiver.start()
def run(self):
# Initiate the connection to the server
self.connection.connect((self.host, self.server_port))
def disconnect(self):
self.messageReceiver.send_disconnect()
self.connection.close()
quit()
def receive_message(self, message):
self.messageParser.parse(self.printer, message)
def printer(self,time,sender,message_type,message):
melding = ("\n[" +
time +" : " + message_type + "] " +
sender+ ": " + message + "\n>>> ")
print melding
def send_payload(self, data):
if data == "getHistory":
self.messageReceiver.getHistory()
elif data == "getNames":
self.messageReceiver.getNames()
elif data == "getHelp":
self.messageReceiver.getHelp()
else:
self.messageReceiver.sendMessage(data)
def login(self, data):
brukerNavn = self.messageParser.parse_login(data)
self.messageReceiver.send_login(brukerNavn)
class Client:
"""
This is the chat client class
"""
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.host = host
self.server_port = server_port
self.userLoggedIn = False
self.messageReceiver = MessageReceiver(
self, self.connection) # is a thread by itself.
self.userInput = UserInput(self) # is a thread by itself.
self.parser = MessageParser(self)
self.run()
def run(self):
# Initiate the connection to the server
try:
self.connection.connect((self.host, self.server_port))
except:
print "No connection to the server were established. Exiting."
sys.exit()
self.messageReceiver.start() # start the thread
self.userInput.start() # start the thread
print "Client Ready. Please type command. type 'help' to view server commands."
def disconnect(self):
self.connection.close()
print "Server disconnected"
self.userInput.kill()
sys.exit()
pass
def receive_message(self, message):
parsed_message = self.parser.parse(message)
print parsed_message
def send_payload(self, data):
json = self.parser.encode(data)
self.connection.send(json)
pass
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.host = host
self.server_port = server_port
self.run()
self.messageReciever = MessageReceiver(self, self.connection)
self.messageParser = MessageParser()
self.chatClient()
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
self.host = host
self.server_port = server_port
self.logger = Logger(None)
self.parser = MessageParser()
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.run()
def __init__(self, kafka_topic, kafka_servers, kafka_group_id, logger, db):
threading.Thread.__init__(self)
self.consumer = Consumer({
'bootstrap.servers': kafka_servers,
'group.id': kafka_group_id,
'default.topic.config': {
'auto.offset.reset': 'smallest'
}
})
self.topic = kafka_topic
self.experiment_id = kafka_topic.split('-')[
0] # Get experiment ID from topic name.
self.log = logger
self.parser = MessageParser(self.log)
self.kafkaTimeout = 5
self.db = db
class MessageReceiver(threading.Thread):
"""
This is the message receiver class. The class inherits Thread, something that
is necessary to make the MessageReceiver start a new thread, and it allows
the chat client to both send and receive messages at the same time
"""
def __init__(self, client, connection):
"""
This method is executed when creating a new MessageReceiver object
"""
threading.Thread.__init__(self, name=client)
# Flag to run thread as a deamon
self.daemon = True
self.connection = connection
self.parser = MessageParser()
#self.run()
def run(self):
while True:
payload = self.connection.recv(4096)
jresponses = payload.decode("utf-8").split("\0")
for jresponse in jresponses:
if jresponse is not None and len(jresponse) > 0:
try:
response = dejsonify(jresponse)
print(self.parser.parse(response))#, end='')
except:
print("Couldn't dejsonify: ( ", jresponse, " )")
"""
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
self.host = host
self.server_port = server_port
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Set up messageparser
self.message_parser = MessageParser()
try:
self.run()
except KeyboardInterrupt: # Disconnect on keyboard interupt
self.disconnect()
def run(self):
# connect master to get worker's id
self.sock.connect((Config.MASTER_IP, Config.MASTER_PORT))
worker_id = MessageParser().decode_recv(self.sock)
print('Game recv worker id', worker_id)
self.sock.shutdown(2)
self.sock.close()
# try to connect worker
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
while True:
try:
self.sock.connect(('localhost', Config.WORKER_BASE_PORT+worker_id))
break
except Exception as e:
print(e)
time.sleep(1)
self.msg_parser.send_game_model_info(self.sock, self.game.get_game_model_info())
state, reward, done, next_state = self.game.reset()
while True:
self.msg_parser.send_sample(self.sock, [state, reward, done, next_state])
if not done:
action = self.msg_parser.recv_action(self.sock)
state, reward, done, next_state = self.game.step(action)
else:
state, reward, done, next_state = self.game.reset()
class MessageReceiver(Thread):
def __init__(self, client, connection):
super(MessageReceiver, self).__init__()
#self.thread = Thread(target=self.run)
self.daemon = True
self.client = client
self.connection = connection
self.msgParser = MessageParser()
def run(self):
while True:
try:
incomingMessage = self.connection.recv(4096)
except:
print bcolors.WARNING + "Failed when trying to read socket, restart program" + bcolors.ENDC
break
if incomingMessage != "":
parsedMessage = self.msgParser.parse(incomingMessage)
if parsedMessage == "logout":
self.stop()
else:
print(parsedMessage)
#self.stop()
pass
def stop(self):
self.client.disconnect()
class SubredditWatcher:
MAX_ALREADY_DONE_LENGTH = 2000
def __init__(self, name, praw_reddit, triggers, username):
self.name = name
self.praw_reddit = praw_reddit
self.triggers = triggers
self.username = username
self.already_done = []
self.msg_parser = MessageParser(triggers)
def watch(self):
subreddit = self.praw_reddit.get_subreddit(self.name)
util.bot_stdout_print("Getting comments for subreddit: %s" % (self.name))
for submission in subreddit.get_comments():
if submission.id not in self.already_done:
try:
msg = submission.body
successes,failures = self.msg_parser.parse(msg)
self.already_done.append(submission.id)
reply = self.get_reply(submission, successes, failures)
if not reply is None:
util.bot_stdout_print("Reply to %s: %s\n" % (submission.id, reply))
util.handle_ratelimit(submission.reply, reply)
except:
util.bot_stdout_print("Unknown exception: %s" % sys.exc_info()[0])
print traceback.format_exc()
self.already_done.append(submission.id)
self.cleanup_already_done()
def get_reply(self, submission, successes, failures):
if len(successes) > 0:
success_msgs = []
for result in successes:
success_msgs.append("Random integer between %d and %d is %d." % (result["x"], result["y"], result["randnum"]))
reply = " \n".join(success_msgs)
return reply
elif len(failures) > 0:
failure_messages = []
for failure_msg in failures:
failure_messages.append("* %s" % failure_msg)
reply = "The following errors occurred: \n \n"
reply += " \n".join(failure_messages)
reply += " \n \nYou may be doing something incorrectly."
reply += " Please enter the following command to use this bot: "
reply += "\"/u/%s x y\" (where x and y are integers)." % self.username
return reply
def cleanup_already_done(self):
# Thought about just removing everything that is not in the current reddit comment list,
# but I'm not sure how reddit handles comment deletion. I'd hate for the bot to respond twice.
# Instead, I'm just going to keep the list at a maximum length. This will at least keep the
# bot from consuming too much memory.
if len(self.already_done) > self.MAX_ALREADY_DONE_LENGTH:
negative_length = -1 * self.MAX_ALREADY_DONE_LENGTH
self.already_done = self.already_done[negative_length:]
class ExperimentListener(threading.Thread):
def __init__(self, kafka_topic, kafka_servers, kafka_group_id, logger, db):
threading.Thread.__init__(self)
self.consumer = Consumer({
'bootstrap.servers': kafka_servers,
'group.id': kafka_group_id,
'default.topic.config': {
'auto.offset.reset': 'smallest'
}
})
self.topic = kafka_topic
self.experiment_id = kafka_topic.split('-')[
0] # Get experiment ID from topic name.
self.log = logger
self.parser = MessageParser(self.log)
self.kafkaTimeout = 5
self.db = db
def run(self):
self.log.info("[0x%x] Thread started, topic: %s",
threading.get_ident(), self.topic)
self.consumer.subscribe([self.topic])
self.consume()
def consume(self):
running = True
self.log.info("[0x%x] Listening to %s", threading.get_ident(),
self.topic)
writer = mongoWriter(self.db, self.log, self.topic)
while running:
msg = self.consumer.poll(timeout=self.kafkaTimeout)
if msg != None:
if not msg.error():
msgText = msg.value().decode('utf-8')
self.log.debug('[0x%x] Message received: %s',
threading.get_ident(), msgText)
metrics = self.parser.parse_message(msgText)
if metrics != None:
self.log.debug('Metrics recieved - Writing metrics')
writer.write_metrics(metrics)
if msgText in expected_termination_messages:
self.log.info(
"[0x%x] Closing thread. Experiment %s ended because of: %s",
threading.get_ident(), self.experiment_id, msgText)
if msgText == "<EXPERIMENT_COMPLETED>":
writer.update_experiment_state(
self.experiment_id, "completed")
running = False
elif msg.error().code() != KafkaError._PARTITION_EOF:
self.log.error(msg.error())
running = False
else:
time.sleep(5)
self.consumer.close()
def __init__(self, host, server_port):
self.host = host
self.server_port = server_port
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.message_parser = MessageParser()
self.run()
def run(self):
print("GameListenerThread starts running")
while True:
sock, addr = self.server.accept()
print('Master accept connection', sock, addr)
worker = self.master.add_worker()
MessageParser().send(sock, worker.id)
time.sleep(0.1)
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
# Set up the socket connection to the server
self.connection = socket(AF_INET, SOCK_STREAM)
self.host = host
self.server_port = server_port
self.message_reciever = MessageReceiver(self, self.connection)
self.message_parser = MessageParser(self)
self.received_answer = True
self.is_logged_in = False
self.run()
def run(self):
parser = MessageParser()
# TODO: Make MessageReceiver receive and handle payloads
print("Start messageReceiver")
while True:
rawRecvMessage = self.connection.recv(4096)
if rawRecvMessage:
recvMessage = rawRecvMessage.decode()
payload = parser.parse(recvMessage)
if payload['response'] == 'error':
self.errorHandler(payload)
elif payload['response'] == 'info':
self.infoHandler(payload)
elif payload['response'] == 'history':
self.historyHandler(payload)
elif payload['response'] == 'message':
self.messageHandler(payload)
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
self.loggedon = False
# Set up the socket connection to the server
try:
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
except socket.error as e:
print "Failed to create socket. Error message:", e
self.host = host
self.server_port = server_port
self.lastMessageRecieved = None
self.parser = MessageParser()
self.run()
self.rcv = MessageReceiver(self, self.connection)
self.rcv.start()
class MentionsWatcher:
MAX_ALREADY_DONE_LENGTH = 2000
DELAY = 30
def __init__(self, praw_reddit, username):
self.praw_reddit = praw_reddit
self.username = username
self.already_done = []
self.last_run = None
self.msg_parser = MessageParser(username=username)
def watch(self):
now = int(time.time())
if self.last_run is None or now - self.last_run > self.DELAY:
util.bot_stdout_print("Getting mentions for user: %s" % (self.username))
mentions = self.praw_reddit.get_mentions()
self.last_run = int(time.time())
try:
for mention in mentions:
if mention.new == True and mention.id not in self.already_done:
msg = mention.body
successes,failures = self.msg_parser.parse(msg)
reply = self.get_reply(successes, failures)
self.already_done.append(mention.id)
mention.mark_as_read()
if not reply is None:
util.bot_stdout_print("Reply to %s: %s\n" % (mention.id, reply))
util.handle_ratelimit(mention.reply, reply)
except:
util.bot_stdout_print("Unknown exception: %s" % sys.exc_info()[0])
print traceback.format_exc()
self.already_done.append(mention.id)
self.cleanup_already_done()
def get_reply(self, successes, failures):
if len(successes) > 0:
success_msgs = []
for result in successes:
success_msgs.append("Random integer between %d and %d is %d." % (result["x"], result["y"], result["randnum"]))
reply = " \n".join(success_msgs)
return reply
elif len(failures) > 0:
failure_messages = []
for failure_msg in failures:
failure_messages.append("* %s" % failure_msg)
reply = "The following errors occurred: \n \n"
reply += " \n".join(failure_messages)
reply += " \n \nYou may be doing something incorrectly."
reply += " Please enter the following command to use this bot: "
reply += "\"/u/%s x y\" (where x and y are integers)." % self.username
return reply
def cleanup_already_done(self):
if len(self.already_done) > self.MAX_ALREADY_DONE_LENGTH:
negative_length = -1 * self.MAX_ALREADY_DONE_LENGTH
self.already_done = self.already_done[negative_length:]
class Client:
"""
This is the chat client class
"""
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.host = host
self.server_port = server_port
self.username = None
self.parser = MessageParser(self)
self.connection.connect((self.host, self.server_port))
self.receiver = MessageReceiver(self, self.connection)
self.run()
def run(self):
while True:
request = input()
if request == "quit":
self.disconnect()
self.send_payload(request.split(" ", 1))
def disconnect(self):
self.connection.close()
quit()
def logout(self):
self.username = None
print("Logout successful")
def receive_message(self, message):
self.parser.parse(message)
def send_payload(self, data):
payload = json.dumps({
"request": data[0],
"content": data[1] if data[0] in ["msg", "login"] else None
})
self.connection.send(payload.encode())
class MessageReceiver(Thread):
"""
This is the message receiver class. The class inherits Thread, something that
is necessary to make the MessageReceiver start a new thread, and it allows
the chat client to both send and receive messages at the same time
"""
def __init__(self, client, connection):
"""
This method is executed when creating a new MessageReceiver object
"""
self.connection = connection
super(MessageReceiver, self).__init__()
def run(self):
self.MessageParser = MessageParser()
while True:
payload = self.connection.recv(45096)
self.MessageParser.parse(payload)
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.host = host
self.server_port = server_port
self.userLoggedIn = False
self.messageReceiver = MessageReceiver(
self, self.connection) # is a thread by itself.
self.userInput = UserInput(self) # is a thread by itself.
self.parser = MessageParser(self)
self.run()
def __init__(self, host, server_port):
"""
This method is run when creating a new Client object
"""
# Set up the socket connection to the server
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Init
self.host = host
self.server_port = server_port
self.state = State.LOGIN;
self.messageEncoder = MessageEncoder()
self.messageParser = MessageParser()
self.username = ""
# Run client
self.run()
