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 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
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)
