class HandleAuctionRemove(ImmediateTask):
def __init__(self, auction: Auction):
"""
Handles the removal of an auction
:param auction: auction to remove.
:param seconds_to_start: seconds to wait for running the task.
"""
super(HandleAuctionRemove, self).__init__()
self.client_data = ClientMainData()
self.auction_manager = AuctionManager(self.client_data.domain)
self.bidding_object_manager = BiddingObjectManager(self.client_data.domain)
self.agent_processor = AgentProcessor(self.client_data.domain, '')
self.auction = auction
async def _run_specific(self):
try:
self.logger.debug("start Handle Auction Remove - auction: {0}".format(str(self.auction.get_key())))
# remove from processing the auction
self.agent_processor.delete_auction(self.auction)
handle_remove_bidding_objects = HandleRemoveBiddingObjectByAuction(self.auction)
await handle_remove_bidding_objects.start()
self.auction_manager.delete_auction(self.auction.get_key())
self.logger.debug("end Handle Auction Remove - auction: {0}".format(str(self.auction.get_key())))
except Exception as e:
self.logger.error(str(e))
class HandleLoadAuction(ScheduledTask):
"""
Handles auction loading from file.
"""
def __init__(self, file_name: str, seconds_to_start: float):
"""
Method to create the task
:param file_name: file name to load. The file name includes the absolute path.
:param seconds_to_start: seconds for starting the task.
"""
super(HandleLoadAuction, self).__init__(seconds_to_start)
self.file_name = file_name
self.server_main_data = ServerMainData()
self.resource_manager = ResourceManager(self.server_main_data.domain)
self.auction_manager = AuctionManager(self.server_main_data.domain)
self.domain = self.server_main_data.domain
self.immediate_start = self.server_main_data.inmediate_start
self.logger = log().get_logger()
async def _run_specific(self):
"""
Handles auction loading from file.
:return:
"""
try:
auction_file_parser = AuctionXmlFileParser(self.domain)
auctions = auction_file_parser.parse(self.file_name)
for auction in auctions:
if self.resource_manager.verify_auction(auction):
self.auction_manager.add_auction(auction)
# Schedule auction activation
if self.immediate_start:
seconds_to_start = 0
else:
seconds_to_start = (auction.get_start() -
datetime.now()).total_seconds()
activate_task = HandleActivateAuction(
auction=auction, seconds_to_start=seconds_to_start)
activate_task.start()
auction.add_task(activate_task)
seconds_to_start = (auction.get_stop() -
datetime.now()).total_seconds()
removal_task = HandleRemoveAuction(
auction=auction, seconds_to_start=seconds_to_start)
removal_task.start()
auction.add_task(removal_task)
self.logger.info("auction with key {0} added".format(
auction.get_key()))
else:
self.logger.error(
"The auction with key {0} could not be added".format(
auction.get_key()))
except Exception as e:
self.logger.error(
"An error occur during load actions - Error:{}".format(str(e)))
def __init__(self, session: AuctionSession):
self.session_manager = AuctionSessionManager()
self.session = session
self.client_data = ClientMainData()
self.client_message_processor = ClientMessageProcessor()
self.agent_processor = AgentProcessor(self.client_data.domain, "")
self.auction_manager = AuctionManager(self.client_data.domain)
self.logger = log().get_logger()
def __init__(self, session: AuctionSession, bidding_object: BiddingObject,
seconds_to_start: float):
super(HandleActivateBiddingObject, self).__init__(seconds_to_start)
self.session = session
self.bidding_object = bidding_object
self.server_main_data = ServerMainData()
self.auction_manager = AuctionManager(self.server_main_data.domain)
self.auction_processor = AuctionProcessor(self.server_main_data.domain)
def __init__(self, server_connection: ServerConnection, message: IpapMessage, seconds_to_start: float):
super(HandleAskResponseMessage, self).__init__(seconds_to_start)
self.client_data = ClientMainData()
self.server_connection = server_connection
self.resource_request_interval: ResourceRequestInterval = \
server_connection.get_auction_session().resource_request_interval
self.message = message
self.agent_template_container = AgentTemplateContainerManager()
self.auction_manager = AuctionManager(self.client_data.domain)
self.agent_processor = AgentProcessor(self.client_data.domain, '')
self.template_container = None
def __init__(self, session: AuctionSession, ipap_message: IpapMessage,
seconds_to_start: float):
super(HandleAddBiddingObjects, self).__init__(seconds_to_start)
self.session = session
self.ipap_message = ipap_message
self.server_main_data = ServerMainData()
self.server_message_processor = ServerMessageProcessor()
self.bididing_manager = BiddingObjectManager(
self.server_main_data.domain)
self.auction_manager = AuctionManager(self.server_main_data.domain)
self.template_container = IpapTemplateContainerSingleton()
self.logger = log().get_logger()
def __init__(self, auction: Auction):
"""
Handles the removal of an auction
:param auction: auction to remove.
:param seconds_to_start: seconds to wait for running the task.
"""
super(HandleAuctionRemove, self).__init__()
self.client_data = ClientMainData()
self.auction_manager = AuctionManager(self.client_data.domain)
self.bidding_object_manager = BiddingObjectManager(self.client_data.domain)
self.agent_processor = AgentProcessor(self.client_data.domain, '')
self.auction = auction
def __init__(self, file_name: str, seconds_to_start: float):
"""
Method to create the task
:param file_name: file name to load. The file name includes the absolute path.
:param seconds_to_start: seconds for starting the task.
"""
super(HandleLoadAuction, self).__init__(seconds_to_start)
self.file_name = file_name
self.server_main_data = ServerMainData()
self.resource_manager = ResourceManager(self.server_main_data.domain)
self.auction_manager = AuctionManager(self.server_main_data.domain)
self.domain = self.server_main_data.domain
self.immediate_start = self.server_main_data.inmediate_start
self.logger = log().get_logger()
def __init__(self, session: AuctionSession, message: IpapMessage,
seconds_to_start: float):
"""
:param seconds_to_start:
"""
super(HandleAskRequest, self).__init__(seconds_to_start)
self.session = session
self.message = message
self.server_main_data = ServerMainData()
self.auction_manager = AuctionManager(self.server_main_data.domain)
self.auction_processor = AuctionProcessor(self.server_main_data.domain)
self.field_manager = FieldDefManager()
self.message_processor = ServerMessageProcessor()
self.template_container = IpapTemplateContainerSingleton()
class HandleActivateBiddingObject(ScheduledTask):
"""
Handles the activate of a bidding object. When active the bidding object is included in the auction for bidding.
"""
def __init__(self, session: AuctionSession, bidding_object: BiddingObject,
seconds_to_start: float):
super(HandleActivateBiddingObject, self).__init__(seconds_to_start)
self.session = session
self.bidding_object = bidding_object
self.server_main_data = ServerMainData()
self.auction_manager = AuctionManager(self.server_main_data.domain)
self.auction_processor = AuctionProcessor(self.server_main_data.domain)
async def _run_specific(self):
try:
self.logger.info("activating bidding_object with key: {0}".format(
self.bidding_object.get_key()))
auction = self.auction_manager.get_auction(
self.bidding_object.get_parent_key())
if auction.get_state() == AuctioningObjectState.ACTIVE:
self.auction_processor.add_bidding_object_to_auction_process(
auction.get_key(), self.bidding_object)
self.bidding_object.set_state(AuctioningObjectState.ACTIVE)
else:
raise ValueError("Auction {0} is not active".format(
auction.get_key()))
except Exception as e:
self.logger.error(str(e))
def get_ipap_message(
self, bidding_objects: List[BiddingObject],
template_container: IpapTemplateContainer) -> IpapMessage:
"""
get the ipap_message that contains all the bidding objects within the list given
:param bidding_objects: bidding objects to include in the message.
:param template_container: container with all the registered templates
:return: ipap_message with the information
"""
ipap_bidding_object_parser = IpapBiddingObjectParser(self.domain)
message = IpapMessage(self.domain, IpapMessage.IPAP_VERSION, True)
auction_manager = AuctionManager(self.domain)
for bidding_object in bidding_objects:
auction = auction_manager.get_auction(
bidding_object.get_parent_key())
ipap_bidding_object_parser.get_ipap_message(
bidding_object, auction, template_container, message)
return message
def get_ipap_message(self, allocation: Allocation, template_container: IpapTemplateContainer) -> IpapMessage:
"""
:return:
"""
message = IpapMessage(self.domain, IpapMessage.IPAP_VERSION, True)
auction_manager = AuctionManager(self.domain)
auction = auction_manager.get_auction(allocation.get_auction_key())
# Find both templates types for the bidding object.
temp_type = IpapTemplate.get_data_template(allocation.get_template_object_type())
data_template_id = auction.get_bidding_object_template(allocation.get_template_object_type(), temp_type)
temp_type = IpapTemplate.get_opts_template(allocation.get_template_object_type())
option_template_id = auction.get_bidding_object_template(allocation.get_template_object_type(), temp_type)
# Insert allocations's templates.a
data_template = template_container.get_template(data_template_id)
message.make_template(data_template)
option_template = template_container.get_template(option_template_id)
message.make_template(option_template)
# Include data records.
self.include_data_record(data_template, allocation, 'Record_1', allocation.config_params, message)
# Include option records.
index = 1
for interval in allocation.intervals:
record_id = 'Record_{0}'.format(str(index))
self.include_options_record(option_template, allocation,
record_id, interval.start, interval.stop, message)
index = index + 1
return message
def __init__(self, stop_datetime: datetime, resource_request: ResourceRequest, seconds_to_start: float):
"""
Method to create the task remove resource request interval
:param stop_datetime: date and time when the resource request interval should be removed.
:param resource_request: resource request that should be started.
:param seconds_to_start: seconds for starting the task.
"""
super(HandleRemoveResourceRequestInterval, self).__init__(seconds_to_start)
self.stop_datetime = stop_datetime
self.resource_request = resource_request
self.seconds_to_start = seconds_to_start
self.client_data = ClientMainData()
self.auction_session_manager = AuctionSessionManager()
self.agent_processor = AgentProcessor(self.client_data.domain, "")
self.auction_manager = AuctionManager(self.client_data.domain)
self.client_message_processor = ClientMessageProcessor()
class HandleRemoveBiddingObject(ScheduledTask):
"""
Handles the removal of a bidding object. This removes the bidding object from the auction for bidding.
"""
def __init__(self, session: AuctionSession, bidding_object: BiddingObject,
periods_to_maintain: int, seconds_to_start: float):
super(HandleRemoveBiddingObject, self).__init__(seconds_to_start)
self.session = session
self.bidding_object = bidding_object
self.periods_to_maintain = periods_to_maintain
self.server_main_data = ServerMainData()
self.bidding_manager = BiddingObjectManager(
self.server_main_data.domain)
self.auction_manager = AuctionManager(self.server_main_data.domain)
self.auction_processor = AuctionProcessor(self.server_main_data.domain)
async def _run_specific(self):
try:
self.logger.info("bidding object remove key: {0}".format(
self.bidding_object.get_key()))
# Wait for the bid to complete execution.
if self.bidding_object.get_type() == AuctioningObjectType.BID:
while self.bidding_object.get_execution_periods(
) <= self.periods_to_maintain:
self.logger.info(
"inactivate bidding object number of periods:{0}".
format(str(
self.bidding_object.get_execution_periods())))
# we have to wait for the process request to execute
await asyncio.sleep(1)
auction = self.auction_manager.get_auction(
self.bidding_object.get_parent_key())
if auction.get_state() == AuctioningObjectState.ACTIVE:
self.auction_processor.delete_bidding_object_from_auction_process(
auction.get_key(), self.bidding_object)
self.bidding_manager.del_actioning_object(
self.bidding_object.get_key())
else:
raise ValueError("Auction {0} is not active".format(
auction.get_key()))
except Exception as e:
self.logger.error(str(e))
def __init__(self, request_process_key: str, bidding_objects: List[BiddingObject], seconds_to_start: float):
"""
Handles the generation of new bidding objects
:param request_process_key: process key where the bidding objects have been generated
:param bidding_objects: bidding object list to include
:param seconds_to_start: seconds to wait for running the task.
"""
super(HandledAddGenerateBiddingObject, self).__init__(seconds_to_start)
self.request_process_key = request_process_key
self.bidding_objects = bidding_objects
self.client_data = ClientMainData()
self.agent_processor = AgentProcessor(self.client_data.domain, '')
self.auction_session_manager = AuctionSessionManager()
self.auction_manager = AuctionManager(self.client_data.domain)
self.agent_template_container = AgentTemplateContainerManager()
self.bidding_manager = BiddingObjectManager(self.client_data.domain)
self.message_processor = ClientMessageProcessor()
class RemoveResourceRequestInterval:
def __init__(self, session: AuctionSession):
self.session_manager = AuctionSessionManager()
self.session = session
self.client_data = ClientMainData()
self.client_message_processor = ClientMessageProcessor()
self.agent_processor = AgentProcessor(self.client_data.domain, "")
self.auction_manager = AuctionManager(self.client_data.domain)
self.logger = log().get_logger()
async def process_remove(self):
self.logger.info('starting process remove request interval - session {0}'.format(self.session.get_key()))
# searches the request interval
resource_request_interval = self.session.get_resource_request_interval()
self.logger.info(resource_request_interval.start)
# removes the request interval
auctions = self.session.get_auctions()
self.logger.info('nbr auctions {0}'.format(str(len(auctions))))
# deletes active request process associated with this request interval.
resource_request_process_ids = resource_request_interval.get_resource_request_process()
self.logger.info('starting process request to remove: {0}'.format(str(resource_request_process_ids)))
for resource_request_process_id in resource_request_process_ids:
self.agent_processor.delete_request(resource_request_process_id)
# deletes the reference to the auction (a session is not referencing it anymore)
auctions_to_remove = self.auction_manager.decrement_references(auctions, self.session.get_key())
for auction in auctions_to_remove:
handle_auction_remove = HandleAuctionRemove(auction)
await handle_auction_remove.start()
await resource_request_interval.stop_tasks()
self.logger.info('ending process remove request interval')
def _initialize_managers(self):
"""
Initializes managers used.
:return:
"""
self.logger.debug("Starting _initialize_managers")
self.auction_manager = AuctionManager(self.domain)
self.database_manager = DataBaseManager(
Config().get_config_param('DataBase', 'Type'),
Config().get_config_param('DataBase', 'Host'),
Config().get_config_param('DataBase', 'User'),
Config().get_config_param('DataBase', 'Password'),
Config().get_config_param('DataBase', 'Port'),
Config().get_config_param('DataBase', 'DbName'),
Config().get_config_param('DataBase', 'MinSize'),
Config().get_config_param('DataBase', 'MaxSize'))
self.bidding_object_manager = BiddingObjectManager(self.domain)
self.resource_request_manager = ResourceRequestManager(self.domain)
self.auction_session_manager = AuctionSessionManager()
self.logger.debug("Ending _initialize_managers")
class HandleInactivateBiddingObject(ScheduledTask):
"""
Handles the removal of a bidding object from the auction process.
"""
def __init__(self, bidding_object: BiddingObject, seconds_to_start: float):
super(HandleInactivateBiddingObject, self).__init__(seconds_to_start)
self.bidding_object = bidding_object
self.server_main_data = ClientMainData()
self.bidding_manager = BiddingObjectManager(self.server_main_data.domain)
self.auction_manager = AuctionManager(self.server_main_data.domain)
async def _run_specific(self):
try:
auction = self.auction_manager.get_auction(self.bidding_object.get_parent_key())
if auction.get_state() == AuctioningObjectState.ACTIVE:
self.bidding_object.set_state(AuctioningObjectState.SCHEDULED)
else:
raise ValueError("Auction {0} is not active".format(auction.get_key()))
except Exception as e:
self.logger.error(str(e))
class HandleRemoveBiddingObject(ScheduledTask):
"""
Handles the removal of a bidding object. This removes the bidding object from the auction for bidding.
"""
def __init__(self, bidding_object: BiddingObject, seconds_to_start: float):
super(HandleRemoveBiddingObject, self).__init__(seconds_to_start)
self.bidding_object = bidding_object
self.server_main_data = ClientMainData()
self.bidding_manager = BiddingObjectManager(self.server_main_data.domain)
self.auction_manager = AuctionManager(self.server_main_data.domain)
async def _run_specific(self):
try:
self.logger.info("starting HandleRemoveBiddingObject key {0}".format(self.bidding_object.get_key()))
auction = self.auction_manager.get_auction(self.bidding_object.get_parent_key())
if auction.get_state() == AuctioningObjectState.ACTIVE:
await self.bidding_object.stop_tasks([self])
self.bidding_manager.delete_bidding_object(self.bidding_object.get_key())
else:
raise ValueError("Auction {0} is not active".format(auction.get_key()))
except Exception as e:
self.logger.error(str(e))
class HandleAskResponseMessage(ScheduledTask):
def __init__(self, server_connection: ServerConnection, message: IpapMessage, seconds_to_start: float):
super(HandleAskResponseMessage, self).__init__(seconds_to_start)
self.client_data = ClientMainData()
self.server_connection = server_connection
self.resource_request_interval: ResourceRequestInterval = \
server_connection.get_auction_session().resource_request_interval
self.message = message
self.agent_template_container = AgentTemplateContainerManager()
self.auction_manager = AuctionManager(self.client_data.domain)
self.agent_processor = AgentProcessor(self.client_data.domain, '')
self.template_container = None
def get_template_container(self):
"""
Gets the template container for the particular server.
"""
self.logger.debug("starting get_template_container")
domain = self.message.get_domain()
if domain > 0:
try:
self.template_container = self.agent_template_container.get_template_container(domain)
except ValueError:
template_container = IpapTemplateContainer()
self.agent_template_container.add_template_container(domain, template_container)
self.template_container = template_container
else:
self.logger.error("Invalid domain id associated with the message")
raise ValueError("Invalid domain id associated with the message")
self.logger.debug("ending get_template_container")
def create_auctions(self, auctions: List[Auction]) -> int:
"""
Creates the auctions answered by the server as being used to bid for the resource
:param auctions:list of auctions
:return: maximum duration interval.
"""
self.logger.debug("starting create_auctions")
# This variable maintains the auction with the maximal duration interval, so
# The request should last at least an interval multiple.
max_interval = 0
for auction in auctions:
# search the auction in the auction container, if it exists then updates its intervals.
try:
auction2 = self.auction_manager.get_auction(auction.get_key())
interval = auction2.get_interval()
if auction2.get_start() > self.resource_request_interval.start:
auction2.set_start(self.resource_request_interval.start)
if auction2.get_stop() < self.resource_request_interval.stop:
auction2.set_stop(self.resource_request_interval.stop)
when = DateUtils().calculate_when(auction2.get_stop())
except ValueError:
# the auction does not exists, so we need to create a new auction process.
interval = auction.get_interval()
auction.intersect_interval(interval.start, interval.stop)
val_interval = interval.interval
if val_interval > 0:
duration = (auction.get_stop() - auction.get_start()).total_seconds()
bid_intervals = floor(duration / val_interval)
modulus = fmod(duration, val_interval)
# If the requested time is less than the minimal interval for the auction
# we have to request te minimal interval.
if modulus > 0:
new_stop = auction.get_start() + timedelta(interval.interval * (bid_intervals + 1))
auction.set_stop(new_stop)
self.auction_manager.add_auction(auction)
# Update the maximum interval for the auction.
if max_interval < interval.interval:
max_interval = interval.interval
self.logger.debug("ending create_auctions")
return max_interval
def create_process_request(self, auctions: list, max_interval: int, server_domain: int):
"""
:param auctions: list of auction to put to process
:param max_interval: the auction with the maximal duration interval
:return:
"""
self.logger.debug("starting process request")
# Go through the list of auctions and create groups by their module
auctions_by_module = {}
for auction in auctions:
module_name = auction.get_module_name()
if module_name not in auctions_by_module:
auctions_by_module[module_name] = []
auctions_by_module[module_name].append(auction)
req_start = self.resource_request_interval.start
req_stop = self.resource_request_interval.stop
first_time = True
resource_request_key = None
for module_name in auctions_by_module:
auctions = auctions_by_module[module_name]
resource_request_key = None
for auction in auctions:
if first_time:
if max_interval > 0:
bid_intervals = floor((req_stop - req_start).total_seconds() / max_interval)
duration = max_interval * (bid_intervals + 1)
req_stop = req_start + timedelta(seconds=duration)
resource_request_key = self.agent_processor.add_request(
self.server_connection.get_auction_session().get_key(),
self.resource_request_interval.get_fields(),
auction, server_domain, req_start, req_stop)
self.resource_request_interval.add_resource_request_process(resource_request_key)
first_time = False
else:
self.agent_processor.add_auction_request(resource_request_key, auction)
when = DateUtils.calculate_when(req_start)
handle_request_process_execution = HandleRequestProcessExecution(resource_request_key, when)
handle_request_process_execution.start()
self.resource_request_interval.add_task(handle_request_process_execution)
when = DateUtils.calculate_when(req_stop)
handle_request_process_remove = HandleRequestProcessRemove(resource_request_key, when)
handle_request_process_remove.start()
self.resource_request_interval.add_task(handle_request_process_remove)
self.logger.debug("ending process request")
async def _run_specific(self):
try:
self.get_template_container()
auctions = self.auction_manager.parse_ipap_message(self.message, self.template_container)
max_interval = self.create_auctions(auctions)
self.create_process_request(auctions, max_interval, self.message.get_domain())
self.auction_manager.increment_references(auctions, self.server_connection.get_auction_session().get_key())
self.server_connection.get_auction_session().set_auctions(auctions)
except Exception as e:
self.logger.error(str(e))
def __init__(self, bidding_object: BiddingObject, seconds_to_start: float):
super(HandleRemoveBiddingObject, self).__init__(seconds_to_start)
self.bidding_object = bidding_object
self.server_main_data = ClientMainData()
self.bidding_manager = BiddingObjectManager(self.server_main_data.domain)
self.auction_manager = AuctionManager(self.server_main_data.domain)
class HandleAskRequest(ScheduledTask):
"""
Handles an ask request from an agent. This request is performed to get auctions applicable for a resource.
"""
def __init__(self, session: AuctionSession, message: IpapMessage,
seconds_to_start: float):
"""
:param seconds_to_start:
"""
super(HandleAskRequest, self).__init__(seconds_to_start)
self.session = session
self.message = message
self.server_main_data = ServerMainData()
self.auction_manager = AuctionManager(self.server_main_data.domain)
self.auction_processor = AuctionProcessor(self.server_main_data.domain)
self.field_manager = FieldDefManager()
self.message_processor = ServerMessageProcessor()
self.template_container = IpapTemplateContainerSingleton()
def is_complete(self, session_info: dict):
"""
Establishes if the session info given as part of the message is complete.
:param session_info: session information given.
:return: true or false
"""
agent_session_set = self.auction_processor.get_set_field(
AgentFieldSet.SESSION_FIELD_SET_NAME)
return len(session_info) == len(agent_session_set)
async def _run_specific(self):
"""
Handles a session request from an agent.
"""
try:
auctions = self.auction_processor.get_applicable_auctions(
self.message)
self.logger.debug("number of applicable auctions: {0}".format(
len(auctions)))
session_info = self.auction_processor.get_session_information(
self.message)
if self.server_main_data.use_ipv6:
s_address = self.server_main_data.ip_address6.__str__()
else:
s_address = self.server_main_data.ip_address4.__str__()
if self.is_complete(session_info):
message_to_send = self.auction_manager.get_ipap_message(
auctions, self.server_main_data.use_ipv6, s_address,
self.server_main_data.local_port)
message_to_send.set_ack_seq_no(self.message.get_seqno())
message_to_send.set_seqno(self.session.get_next_message_id())
await self.message_processor.send_message(
self.session.get_connection(),
message_to_send.get_message())
else:
ack_message = self.message_processor.build_ack_message(
self.session.get_next_message_id(),
self.message.get_seqno())
await self.message_processor.send_message(
self.session.get_connnection(), ack_message.get_message())
except Exception as e:
self.logger.error(str(e))
class HandleAddBiddingObjects(ScheduledTask):
"""
This class handles adding a new bidding object sent from an agent to the server.
"""
def __init__(self, session: AuctionSession, ipap_message: IpapMessage,
seconds_to_start: float):
super(HandleAddBiddingObjects, self).__init__(seconds_to_start)
self.session = session
self.ipap_message = ipap_message
self.server_main_data = ServerMainData()
self.server_message_processor = ServerMessageProcessor()
self.bididing_manager = BiddingObjectManager(
self.server_main_data.domain)
self.auction_manager = AuctionManager(self.server_main_data.domain)
self.template_container = IpapTemplateContainerSingleton()
self.logger = log().get_logger()
async def _run_specific(self):
"""
Adds bidding objects sent from an agent.
"""
try:
self.logger.debug("starting HandleAddBiddingObjects")
# parse the message
bidding_objects = self.bididing_manager.parse_ipap_message(
self.ipap_message, self.template_container)
# insert bidding objects to bidding object manager
for bidding_object in bidding_objects:
self.logger.info(
"receiving bidding object with key: {0}".format(
bidding_object.get_key()))
bidding_object.set_session(self.session.get_key())
self.bididing_manager.add_auctioning_object(bidding_object)
i = 0
num_options = len(bidding_object.options)
for option_name in sorted(bidding_object.options.keys()):
interval = bidding_object.calculate_interval(option_name)
when = (interval.start - datetime.now()).total_seconds()
handle_activate = HandleActivateBiddingObject(
self.session, bidding_object, when)
handle_activate.start()
bidding_object.add_task(handle_activate)
auction = self.auction_manager.get_auction(
bidding_object.get_parent_key())
when = (interval.stop - datetime.now()).total_seconds()
# calculates the number of periods that should be active given the auction frequency
periods = math.ceil(when / auction.interval.duration)
if i < num_options - 1:
self.logger.info(
"scheduling bidding object inactivate when: {0}".
format(str(when)))
handle_inactivate = HandleInactivateBiddingObject(
self.session, bidding_object, periods, when)
handle_inactivate.start()
bidding_object.add_task(handle_inactivate)
else:
self.logger.info(
"scheduling bidding object remove when: {0}".
format(str(when)))
handle_inactivate = HandleRemoveBiddingObject(
self.session, bidding_object, periods, when)
handle_inactivate.start()
bidding_object.add_task(handle_inactivate)
i = i + 1
# confirm the message
confim_message = self.server_message_processor.build_ack_message(
self.session.get_next_message_id(),
self.ipap_message.get_seqno())
await self.server_message_processor.send_message(
self.session.get_connection(), confim_message.get_message())
self.logger.debug("ending HandleAddBiddingObjects")
except Exception as e:
self.logger.error(str(e))