def start_provider_backhaul(agntClientVect): logger.debug('Starting start provider backhaul') id = 5 strID = 'Provider5' agent_type = AgentType(AgentType.PROVIDER_BACKHAUL) sellingAddress = agent_properties.addr_mktplace_isp buyingAddress = agent_properties.addr_mktplace_backhaul capacityControl = '' serviceId = '1' # Start the Agent Client list_vars = {} list_vars['Id'] = 5 list_vars['strId'] = strID list_vars['Type'] = agent_type list_vars['SellingAddres'] = agent_properties.addr_mktplace_backhaul list_vars['BuyingAddres'] = '' list_vars['Current_Period'] = 0 list_vars['serviceId'] = 1 list_vars['capacityControl'] = '' list_vars['PurchaseServiceId'] = '' agntClient = AgentClient(list_vars) agntClient.connect_servers(agent_type, strID, sellingAddress, buyingAddress, capacityControl) agntClient.getServiceFromServer(serviceId) agntClient.createAskBids(serviceId) agntClientVect[0] = agntClient
def listen(self): try: self.agentClient = AgentClient(self.afterInit, self.itsdone) self.onInitialized(self.agentClient) except Exception as e: logging.error("Error while sending message to agent " + host + ":" + port) emsg = "{0} ; {0} ; {0} ; {0}".format(e, repr(e), e.message, e.args) logging.error(emsg) print emsg pass
class TrackChangesCore: def __init__(self, settings, onInitialized): self.savePoint = False self.oldText = "" self.window = None self.agentClient = None self.onInitialized = onInitialized self.jsonComposer = JsonComposer(settings.get("host") or "localhost", settings.get("port") or 8885) # start listening in new thread clientThread = Thread(target=self.listen) clientThread.start() self.reg = [] self.afterConnectionInitialized = None # callback, after intialization send init-connection command to agent def afterInit(self, agentClient): print "got initialized agentClient!" agentClient.sendCommand(json.dumps(self.jsonComposer.initConnectionJson())) if self.afterConnectionInitialized != None: print "afterConnectionInitialized" self.afterConnectionInitialized() def insertedit(self, result): lock = Lock() lock.acquire() global INSERTING INSERTING = True print result.op, result.text, "at", result.offset, "in", result.filename for v in sublime.active_window().views(): if v.file_name() == result.filename: edit = v.begin_edit() if result.op == ":insert": v.insert(edit, result.offset, result.text) if result.op == ":delete": v.erase(edit, Region(result.offset, result.offset + len(result.text))) v.end_edit(edit) self.oldText = v.substr(Region(0, v.size())) if not self.savePoint: self.jsonComposer.filename = v.file_name() self.savePoint = True INSERTING = False lock.release() # callback after command was sent def itsdone(self, result): sublime.set_timeout(functools.partial(self.insertedit, result), 1) # sets up AgentClient and listens def listen(self): try: self.agentClient = AgentClient(self.afterInit, self.itsdone) self.onInitialized(self.agentClient) except Exception as e: logging.error("Error while sending message to agent " + host + ":" + port) emsg = "{0} ; {0} ; {0} ; {0}".format(e, repr(e), e.message, e.args) logging.error(emsg) print emsg pass # computes diffs between s1 and s2 def get_diff(self, s1, s2): diffs = [] s = difflib.SequenceMatcher(None, s1, s2) for tag, i1, i2, j1, j2 in s.get_opcodes(): if tag == "insert": diffs.append(("insert", j1, j2)) if tag == "delete": diffs.append(("delete", i1, i2)) return diffs # processes diffs def processDiffs(self, view, diffs, currentText): print "got some diffs. Sending" for d in diffs: if d[1] != d[2]: difftext = "" difflength = 0 if d[0] == "insert": difftext = view.substr(Region(d[1], d[2])) difflength = len(difftext) r1 = d[1] r2 = view.size() - r1 - len(difftext) if d[0] == "delete": difftext = self.oldText[d[1] : d[2]] difflength = -len(difftext) r1 = d[1] r2 = len(self.oldText) - r1 - len(difftext) if difftext != "": self.agentClient.sendCommand( json.dumps(self.jsonComposer.editFileJson(view.file_name(), d[0], r1, r2, difftext)) ) self.oldText = currentText # gets diffs def track_sync(self, view, currentText, filename): try: if not self.savePoint: with open(filename, "rU") as f: originalText = f.read().decode("utf8") self.oldText = originalText self.savePoint = True diffs = self.get_diff(self.oldText, currentText) # execute diff processing sublime.set_timeout(functools.partial(self.processDiffs, view, diffs, currentText), 1) except: pass def addFile(self, fileName, fileId): if not self.agentClient.connected: self.afterConnectionInitialized = self.agentClient.sendCommand( json.dumps(self.jsonComposer.linkFileJson(fileId, fileName)) ) cccpBase = os.environ["CCCP"] print "CCCP agent location: " + cccpBase portFile = cccpBase + "/cccp.port" port = int(open(portFile, "r").read()) self.agentClient.initConnection("localhost", port) else: self.agentClient.sendCommand(json.dumps(self.jsonComposer.linkFileJson(fileId, fileName))) self.reg.append(fileName) # gets currents text and starts diff processing in a new thread def track(self, view): print "Tracking", view.file_name(), "?" if not view.file_name() in self.reg: print "No." return print "Yes." lock = Lock() lock.acquire() global INSERTING if INSERTING == False: currentText = view.substr(Region(0, view.size())) filename = view.file_name() self.diff_thread = Thread(target=self.track_sync, args=(view, currentText, filename)) self.diff_thread.start() self.diff_thread.join() lock.release()
def __init__(self, strID, Id, agent_type, serviceId, agent_seed, sellingAddress, buyingAddress, capacityControl, purchaseServiceId, lock, testThread=False): Process.__init__(self) # state means: 0 can not create bids, # 1 the process can create and ask for bids. # 2 disconnect logger.info('Init agent %s Agent Type:%s', strID, agent_type.getType()) self._used_variables = {} self._list_vars = {} self._list_vars['Id'] = Id self._list_vars['strId'] = strID self._list_vars['Type'] = agent_type self._list_vars['SellingAddres'] = sellingAddress self._list_vars['BuyingAddres'] = buyingAddress self._list_vars['Current_Period'] = 0 self._list_vars['serviceId'] = serviceId self._list_vars['capacityControl'] = capacityControl self._list_vars['PurchaseServiceId'] = purchaseServiceId self._lock = lock self._testThread = testThread self._services = {} randomGenerator = random.Random() randomGenerator.seed(agent_seed) self._list_vars['Random'] = randomGenerator if (agent_type.getType() == AgentType.CONSUMER_TYPE): logger.debug('Starting customer - Agent:%s Agent Type:%s', strID, agent_type.getType()) port = agent_properties.l_port_consumer + Id self._list_vars['Port'] = port self._list_vars['Parameters'] = {} self._list_vars['State'] = AgentServerHandler.IDLE if ((agent_type.getType() == AgentType.PROVIDER_ISP) or (agent_type.getType() == AgentType.PROVIDER_BACKHAUL) or (agent_type.getType() == AgentType.PRESENTER_TYPE)): self._list_vars['Inactive_Bids'] = { } # Bids that are no more in use. self._list_vars['Bids'] = {} # Bids in use. self._list_vars['Bids_Usage'] = {} self._list_vars['Related_Bids'] = { } # for each bid of the provider lists # competitor bids close it. (List) if ((agent_type.getType() == AgentType.PROVIDER_ISP) or (agent_type.getType() == AgentType.PROVIDER_BACKHAUL)): port = agent_properties.l_port_provider + Id self._list_vars['Port'] = port self._list_vars['State'] = AgentServerHandler.IDLE if (agent_type.getType() == AgentType.PRESENTER_TYPE): port = agent_properties.l_port_presenter + Id self._list_vars['Port'] = port self._list_vars['State'] = AgentServerHandler.IDLE self._list_vars['Current_Bids'] = {} self._agntClient = AgentClient(self._list_vars) logger.info('Agent created with arguments %s', self._list_vars)
class Agent(Process): def __init__(self, strID, Id, agent_type, serviceId, agent_seed, sellingAddress, buyingAddress, capacityControl, purchaseServiceId, lock, testThread=False): Process.__init__(self) # state means: 0 can not create bids, # 1 the process can create and ask for bids. # 2 disconnect logger.info('Init agent %s Agent Type:%s', strID, agent_type.getType()) self._used_variables = {} self._list_vars = {} self._list_vars['Id'] = Id self._list_vars['strId'] = strID self._list_vars['Type'] = agent_type self._list_vars['SellingAddres'] = sellingAddress self._list_vars['BuyingAddres'] = buyingAddress self._list_vars['Current_Period'] = 0 self._list_vars['serviceId'] = serviceId self._list_vars['capacityControl'] = capacityControl self._list_vars['PurchaseServiceId'] = purchaseServiceId self._lock = lock self._testThread = testThread self._services = {} randomGenerator = random.Random() randomGenerator.seed(agent_seed) self._list_vars['Random'] = randomGenerator if (agent_type.getType() == AgentType.CONSUMER_TYPE): logger.debug('Starting customer - Agent:%s Agent Type:%s', strID, agent_type.getType()) port = agent_properties.l_port_consumer + Id self._list_vars['Port'] = port self._list_vars['Parameters'] = {} self._list_vars['State'] = AgentServerHandler.IDLE if ((agent_type.getType() == AgentType.PROVIDER_ISP) or (agent_type.getType() == AgentType.PROVIDER_BACKHAUL) or (agent_type.getType() == AgentType.PRESENTER_TYPE)): self._list_vars['Inactive_Bids'] = { } # Bids that are no more in use. self._list_vars['Bids'] = {} # Bids in use. self._list_vars['Bids_Usage'] = {} self._list_vars['Related_Bids'] = { } # for each bid of the provider lists # competitor bids close it. (List) if ((agent_type.getType() == AgentType.PROVIDER_ISP) or (agent_type.getType() == AgentType.PROVIDER_BACKHAUL)): port = agent_properties.l_port_provider + Id self._list_vars['Port'] = port self._list_vars['State'] = AgentServerHandler.IDLE if (agent_type.getType() == AgentType.PRESENTER_TYPE): port = agent_properties.l_port_presenter + Id self._list_vars['Port'] = port self._list_vars['State'] = AgentServerHandler.IDLE self._list_vars['Current_Bids'] = {} self._agntClient = AgentClient(self._list_vars) logger.info('Agent created with arguments %s', self._list_vars) ''' This function connect the agent with all the servers ''' def connect(self): try: strID = self._list_vars['strId'] agent_type = self._list_vars['Type'] sellingAddress = self._list_vars['SellingAddres'] buyingAddress = self._list_vars['BuyingAddres'] capacityControl = self._list_vars['capacityControl'] # Connect to servers. self._agntClient.connect_servers(agent_type, strID, sellingAddress, buyingAddress, capacityControl) # Request the definition of the service except FoundationException as e: raise FoundationException(e.__str__()) ''' This method builds the message to start listening based on parameters for the agent. ''' def build_message(self, port): logger.debug('Build messsage Id: %s', self._list_vars['Id']) port_message = Message("") port_message.setMethod(Message.SEND_PORT) port_message.setParameter("Port", str(port)) agent_type = self._list_vars['Type'] port_message.setParameter("Type", agent_type.getInterfaceName()) logger.debug('Announcing type %s to servers', agent_type.getType()) if ((agent_type.getType() == AgentType.PROVIDER_ISP) or (agent_type.getType() == AgentType.PROVIDER_BACKHAUL)): capacityType = self._list_vars['capacityControl'] if (capacityType == 'B'): port_message.setParameter("CapacityType", "bid") else: port_message.setParameter("CapacityType", "bulk") return port_message ''' This method verifies the results from the servers for the start listening messages ''' def is_correct_start(self, result_clock, result_mkt_place): self.lock.acquire() try: logger.debug('response from the clock server: %s', result_clock.__str__()) logger.debug('response from the market place: %s', result_mkt_place.__str__()) if (result_clock.isMessageStatusOk() and result_mkt_place.isMessageStatusOk()): periodStr = result_mkt_place.getParameter("Period") self._list_vars['Current_Period'] = int(periodStr) logger.info('Servers connected ' + str(periodStr)) return int(periodStr) else: logger.error( 'One of the servers could not establish the connection') logger.debug('Ending listening Id: %s', self._list_vars['Id']) return -1 # Error finally: self.lock.release() ''' This method creates the server for listening messages from the demand server or the marketplace server. ''' def start_agent(self): logger.debug('Starting agent Id: %s Type:%s', self._list_vars['Id'], (self._list_vars['Type']).getType()) self.connect() # Bring the service for purchasing(customer) or selling(provider) serviceId = self._list_vars['serviceId'] self.getServiceFromServer(serviceId) self._service = self._services[serviceId] agent_type = self._list_vars['Type'] # Given the agent type, the software chooses the port to listen. if (agent_type.getType() == AgentType.CONSUMER_TYPE): clockPort = agent_properties.l_port_consumer + ( self._list_vars['Id'] * 3) elif (agent_type.getType() == AgentType.PRESENTER_TYPE): clockPort = agent_properties.l_port_presenter + ( self._list_vars['Id'] * 3) else: clockPort = agent_properties.l_port_provider + ( self._list_vars['Id'] * 3) # Start the clock server self._serverClockServer = AgentListener( agent_properties.addr_agent_clock_server, clockPort, self._lock, self._testThread, self._list_vars) self._serverClockServer.start() if (agent_type.getType() == AgentType.PROVIDER_BACKHAUL): # Start the transit market place listening server mktPlaceTransit = clockPort + 1 self._serverTransitMkrtPlace = AgentListener( agent_properties.addr_agent_mktplace_backhaul, mktPlaceTransit, self._lock, self._testThread, self._list_vars) self._serverTransitMkrtPlace.start() else: # Start the Isp market place listening server mktPlaceIsp = clockPort + 1 self._serverISPMkrtPlace = AgentListener( agent_properties.addr_agent_mktplace_isp, mktPlaceIsp, self._lock, self._testThread, self._list_vars) self._serverISPMkrtPlace.start() # Send the announce the port for the clock server. response3 = '' port_message = self.build_message(clockPort) response3 = self._agntClient.sendMessageClock(port_message) response4 = '' if (agent_type.getType() == AgentType.PROVIDER_BACKHAUL): # send the message to announce the port for the transit market place. port_message = self.build_message(mktPlaceTransit) logger.debug('port message to the market transit: %s', port_message.__str__()) response4 = self._agntClient.sendMessageMarket(port_message) logger.debug('response from the market transit: %s', response4.__str__()) else: # send the message to announce the port for the isp market place. port_message = self.build_message(mktPlaceIsp) logger.debug('port message to the market isp: %s', port_message.__str__()) response4 = self._agntClient.sendMessageMarket(port_message) period = self.is_correct_start(response3, response4) # An error occur, so we have to stop the provider. if (period < 0): self.stop() logger.debug('Ending listening Id: %s', self._list_vars['Id']) return period ''' This method stops the listening for services ''' def stop_agent(self): logger.debug('Stop agent Id: %s name:%s', self._list_vars['Id'], self._list_vars['strId']) self.lock.acquire() logger.debug('Stop agent lock adquired: %s name:%s', self._list_vars['Id'], self._list_vars['strId']) try: # Disconnect from servers. agent_type = self._list_vars['Type'] self._agntClient.disconnect_servers(agent_type) # Stop listeners. logger.debug('Starting stop Id: %s', self._list_vars['Id']) logger.debug('Stoping clockServer Listener Id: %s', self._list_vars['Id']) self._serverClockServer.stop() logger.debug('Stoping market Place Listener Id: %s', self._list_vars['Id']) if (agent_type.getType() == AgentType.PROVIDER_BACKHAUL): self._serverTransitMkrtPlace.stop() else: self._serverISPMkrtPlace.stop() logger.debug('Ending stop Id: %s', self._list_vars['Id']) finally: self.lock.release() def getServiceFromServer(self, serviceId): logger.debug('Starting getServiceFromServer Id: %s', self._list_vars['Id']) try: if (str(serviceId) not in (self._services).keys()): service = self._agntClient.getServiceFromServer(str(serviceId)) self._services[serviceId] = service logger.debug('Ending getServiceFromServer Id: %s', self._list_vars['Id']) except FoundationException as e: logger.error('exception Id:%s - Message:%s', self._list_vars['Id'], e.__str__()) raise FoundationException(e.__str__()) def sendMessageMarket(self, message): return self._agntClient.sendMessageMarket(message) def sendMessageMarketBuy(self, message): return self._agntClient.sendMessageMarketBuy(message) def createAskBids(self, serviceId): return self._agntClient.createAskBids(serviceId) def AskBackhaulBids(self, serviceId): return self._agntClient.AskBackhaulBids(serviceId)