Ejemplo n.º 1
0
    def run(self):
        self.scheduler = ServiceTaskScheduler(self.conf, self.init)
        try:
            self.logger.info("=== Starting ===")
            server_info = self.conf.getGameStateServerInfo()
            self.comm = BotCommClient(server_info.host, server_info.port,
                                      server_info.key, server_info.iv,
                                      "SERVICE_BOT")

            self.comm.start()
            running = True

            while (running):
                msg = self.comm.receive()
                self.logger.debug("recvd msg: %s (%r)" %
                                  (msg.type, str(msg.data)))

                if (msg.type == "EXECUTE_ROUND"):
                    round = msg.data
                    self.logger.info("=== Service Round(%d) Starting ===" %
                                     round)
                    results = self.scheduler.execute(round)
                    result_msg = self.__parseResults(round, results)
                    self.comm.send(result_msg)
                    self.logger.debug("Results: %r" % str(result_msg.data))
                    self.logger.info("=== Service Round(%d) Ending ===" %
                                     round)

                elif (msg.type == "TERMINATE"):
                    self.logger.info("Received TERM message from gameserver")
                    running = False

                else:
                    self.logger.error("Unknown message: %s %s" %
                                      (msg.type, str(msg.data)))
                    assert (False)

        except KeyboardInterrupt:
            self.logger.warn("Servicebot caught Keyboard Interrupt!")

        finally:
            #cleanup
            self.logger.info("Terminating...")
            # FIXME - What is this comment for?
            print "WTF", self.scheduler
            self.scheduler.quit()
            self.comm.kill()
            self.logger.info("Terminated...")
	def testSimpleSchedule(self):
		round = 0
		scheduler = ServiceTaskScheduler(self.conf,True)
		
		start = time.time()
		results = scheduler.execute(round)
		end = time.time()

		run_time = end - start
		self.assert_(4.0 < run_time and run_time < 6.0)

		for team,service,task in results:
			self.assertNotEqual(None,task.error())
			self.assertEquals(None,task.prevFlag())

		scheduler.quit()
	def testCookie(self):
		conf = Config()

		servicebot_conf = ServiceBotConfig()
		servicebot_conf.min_duration_seconds = 2
		servicebot_conf.max_duration_seconds = 2
		servicebot_conf.addServiceInfo(
			"Service",
			modulePath()+"/testservices/StoreService.py",
			1,
			1,1)

		conf.addSection("SERVICE_BOT",servicebot_conf)

		conf.addTeamInfo("Team1","127.0.0.1","127.0.0.0/24")
		conf.addTeamInfo("Team1","127.0.0.1","127.0.0.0/24")
		
		gamestate = GameStateServerInfo(
			"localhost",
			4242,
			"0123456789012345",
			"ABCDEFGH")
		conf.setGameStateServerInfo(gamestate)

		scheduler = ServiceTaskScheduler(conf,True)
		scheduler.execute(0)
		results = scheduler.execute(1)

		for team,service,task in results:
			self.assertEquals(task.cookie(),"Worked")

		scheduler.quit()
Ejemplo n.º 4
0
	def run(self):
		self.scheduler = ServiceTaskScheduler(self.conf,self.init)
		try:
			self.logger.info("=== Starting ===")
			server_info = self.conf.getGameStateServerInfo()
			self.comm = BotCommClient(
				server_info.host,
				server_info.port,
				server_info.key,
				server_info.iv,
				"SERVICE_BOT")
		

			self.comm.start()
			running = True

			while(running):
				msg = self.comm.receive()
				self.logger.debug("recvd msg: %s (%r)" % (msg.type,str(msg.data)))

				if(msg.type == "EXECUTE_ROUND"):
					round = msg.data
					self.logger.info("=== Service Round(%d) Starting ===" % round)
					results = self.scheduler.execute(round)
					result_msg = self.__parseResults(round,results)
					self.comm.send(result_msg)
					self.logger.debug("Results: %r" % str(result_msg.data))
					self.logger.info("=== Service Round(%d) Ending ===" % round)

				elif(msg.type == "TERMINATE"):
					self.logger.info("Received TERM message from gameserver")
					running = False

				else:
					self.logger.error("Unknown message: %s %s" % (msg.type,str(msg.data)))
					assert(False)

		except KeyboardInterrupt:
			self.logger.warn("Servicebot caught Keyboard Interrupt!")

		finally:
			#cleanup
			self.logger.info("Terminating...")
			# FIXME - What is this comment for?
			print "WTF",self.scheduler
			self.scheduler.quit()
			self.comm.kill()
			self.logger.info("Terminated...")
Ejemplo n.º 5
0
class ServiceBot(Process):

	def __init__(self,conf,init=False):
		Process.__init__(self)
		self.conf = conf
		self.servicebot_conf = conf.getSection("SERVICE_BOT")

		self.comm = None
		self.init = init
		self.logger = conf.buildLogger("ServiceBot")

		self.scheduler = None

	def run(self):
		self.scheduler = ServiceTaskScheduler(self.conf,self.init)
		try:
			self.logger.info("=== Starting ===")
			server_info = self.conf.getGameStateServerInfo()
			self.comm = BotCommClient(
				server_info.host,
				server_info.port,
				server_info.key,
				server_info.iv,
				"SERVICE_BOT")
		

			self.comm.start()
			running = True

			while(running):
				msg = self.comm.receive()
				self.logger.debug("recvd msg: %s (%r)" % (msg.type,str(msg.data)))

				if(msg.type == "EXECUTE_ROUND"):
					round = msg.data
					self.logger.info("=== Service Round(%d) Starting ===" % round)
					results = self.scheduler.execute(round)
					result_msg = self.__parseResults(round,results)
					self.comm.send(result_msg)
					self.logger.debug("Results: %r" % str(result_msg.data))
					self.logger.info("=== Service Round(%d) Ending ===" % round)

				elif(msg.type == "TERMINATE"):
					self.logger.info("Received TERM message from gameserver")
					running = False

				else:
					self.logger.error("Unknown message: %s %s" % (msg.type,str(msg.data)))
					assert(False)

		except KeyboardInterrupt:
			self.logger.warn("Servicebot caught Keyboard Interrupt!")

		finally:
			#cleanup
			self.logger.info("Terminating...")
			print "WTF",self.scheduler
			self.scheduler.quit()
			self.comm.kill()
			self.logger.info("Terminated...")
	
	
	def __parseResults(self,round,task_results):
		results = []

		for teamId in xrange(self.conf.numTeams()):
			results.append([])
			for serviceId in xrange(self.servicebot_conf.numServices()):
				results[teamId].append(None)

		for team,service,task in task_results:
			if(task.gotExpectedFlag()):
				results[team.id][service.id] = 'g'
		
			elif(task.error() == None and task.retcode() == 0):
				results[team.id][service.id] = 'b'
					
			else:
				results[team.id][service.id] = 'e'

		for teamId in xrange(self.conf.numTeams()):
			for serviceId in xrange(self.servicebot_conf.numServices()):
				assert(results[teamId][serviceId] != None)

		return BotMessage("SERVICE_RESULTS",(round,results))
Ejemplo n.º 6
0
class ServiceBot(Process):
    def __init__(self, conf, init=False):
        Process.__init__(self)
        self.conf = conf
        self.servicebot_conf = conf.getSection("SERVICE_BOT")

        self.comm = None
        self.init = init
        self.logger = conf.buildLogger("ServiceBot")

        self.scheduler = None

    def run(self):
        self.scheduler = ServiceTaskScheduler(self.conf, self.init)
        try:
            self.logger.info("=== Starting ===")
            server_info = self.conf.getGameStateServerInfo()
            self.comm = BotCommClient(server_info.host, server_info.port,
                                      server_info.key, server_info.iv,
                                      "SERVICE_BOT")

            self.comm.start()
            running = True

            while (running):
                msg = self.comm.receive()
                self.logger.debug("recvd msg: %s (%r)" %
                                  (msg.type, str(msg.data)))

                if (msg.type == "EXECUTE_ROUND"):
                    round = msg.data
                    self.logger.info("=== Service Round(%d) Starting ===" %
                                     round)
                    results = self.scheduler.execute(round)
                    result_msg = self.__parseResults(round, results)
                    self.comm.send(result_msg)
                    self.logger.debug("Results: %r" % str(result_msg.data))
                    self.logger.info("=== Service Round(%d) Ending ===" %
                                     round)

                elif (msg.type == "TERMINATE"):
                    self.logger.info("Received TERM message from gameserver")
                    running = False

                else:
                    self.logger.error("Unknown message: %s %s" %
                                      (msg.type, str(msg.data)))
                    assert (False)

        except KeyboardInterrupt:
            self.logger.warn("Servicebot caught Keyboard Interrupt!")

        finally:
            #cleanup
            self.logger.info("Terminating...")
            # FIXME - What is this comment for?
            print "WTF", self.scheduler
            self.scheduler.quit()
            self.comm.kill()
            self.logger.info("Terminated...")

    def __parseResults(self, round, task_results):
        results = []

        for teamId in xrange(self.conf.numTeams()):
            results.append([])
            for serviceId in xrange(self.servicebot_conf.numServices()):
                results[teamId].append(None)

        for team, service, task in task_results:
            if (task.gotExpectedFlag()):
                results[team.id][service.id] = 'g'

            elif (task.error() == None and task.retcode() == 0):
                results[team.id][service.id] = 'b'

            else:
                results[team.id][service.id] = 'e'

        for teamId in xrange(self.conf.numTeams()):
            for serviceId in xrange(self.servicebot_conf.numServices()):
                assert (results[teamId][serviceId] != None)

        return BotMessage("SERVICE_RESULTS", (round, results))