Python Logger.trace方法代码示例

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import trace [as 别名]
    def handle_routing_packet(self, packet, dynamic):
        """
        Updates the cost and routing tables using the given routing packet

        :param packet: Routing packet to update tables for
        :type packet: RoutingPacket
        :param dynamic: Whether we're handling a dynamic or static packet
        :type dynamic: bool
        :return: Nothing
        :rtype: None
        """
        # No routing table yet. Begin creation, then handle this packet
        if not self._get_intermediate_routing_table(dynamic):
            self.create_routing_table(dynamic)
        did_update = False
        cost_table = packet.costTable
        src_id = packet.src.id

        # Get the appropriate routing table
        routing_table = self._get_intermediate_routing_table(dynamic)
        # Update costs by adding the cost to travel to the source node
        src_cost = routing_table[src_id].cost
        for identifier in cost_table.keys():
            cost_table[identifier] = cost_table[identifier] + src_cost

        src_link = routing_table[src_id].link
        # Update our routing table based on the received table
        for identifier, cost in cost_table.items():
            # New entry to tables or smaller cost
            if identifier not in routing_table or \
                    cost < routing_table[identifier].cost:
                did_update = True
                routing_table[identifier] = LinkCostTuple(src_link, cost)

        # Store and broadcast the updated table if an update occurred
        if did_update:
            self.sameDataCounter = 0
            self.store_routing_table(dynamic, routing_table)
            new_cost_table = self.cost_table_from_routing_table(dynamic)
            self.broadcast_table(new_cost_table, dynamic)
        else:
            self.sameDataCounter += 1
            # Log the same data receipt
            Logger.debug(Network.get_time(), "%s received no new routing table "
                                             "data." % self)
            # Log finalized routing table
            Logger.trace(Network.get_time(), "%s final %s routing table:"
                         % (self, "dynamic" if dynamic else "static"))
            if dynamic:
                self.handle_same_dynamic_routing_table()

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import trace [as 别名]
    def execute(self, time):
        """
        Executes all events that were to be dispatched by the current time.

        :param time: The current time.
        :type time: int
        :return: True if there are still events left in the queue
        :rtype: bool
        """
        # Execute events
        for event_time in sorted(self.queue.keys()):
            if event_time <= time:
                for event in self.queue.pop(event_time, []):
                    Logger.trace(event_time, "Executing event %s" % event)
                    # Filter graph events
                    if isinstance(event, GraphEvent):
                        self.graph_events.append(event)
                    # Filter PacketReceived events to create flow through. graph
                    if isinstance(event, PacketReceivedEvent):
                        self.packet_received_events.append(event)
                    event.execute()
            else:
                break
        # Execute timers
        for timer_time in sorted(self.timers.keys()):
            if timer_time <= time:
                for timer_tuple in self.timers.pop(timer_time):
                    # Get the event and execute it
                    event = timer_tuple.event
                    interval = timer_tuple.interval
                    event.time = time
                    event.execute()
                    # Put the timer back on the queue with the next exec time
                    self.add_timer(event, time, interval)
            else:
                break
        return len(self.queue) != 0

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import trace [as 别名]
    def update_dynamic_routing_table(self, routing_table):
        """
        Replace the old dynamicRoutingTable with the given new one

        :param routing_table: Routing table to update the old one with
        :type routing_table: dict[str, LinkCostTuple]
        :return: Nothing
        :rtype: None
        """
        Logger.trace(Network.get_time(), "%s:" % self)
        Logger.trace(Network.get_time(), "Replacing old dynamic routing table:")
        self.print_routing_table(self.dynamicRoutingTable)
        Logger.trace(Network.get_time(), "With new dynamic routing table:")
        self.print_routing_table(self.newDynamicRoutingTable)
        self.dynamicRoutingTable = routing_table

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import trace [as 别名]
 def print_routing_table(routing_table):
     if not routing_table:
         Logger.trace(Network.get_time(), "None")
         return
     for i, j in routing_table.items():
         Logger.trace(Network.get_time(), "\t%s: %s" % (i, j))