Python Logger.info方法代码示例

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
    def receive(self, packet, time):
        """
        Handles receipt of a packet.

        Args:
            packet (Packet):                The packet.
            time (float):                   Time the packet was received
        """
        Logger.info(time, "%s received packet %s" % (self, packet))
        # Get the appropriate routing table
        routing_table = self.get_routing_table()
        # Update the current routing table with the routing packet
        if isinstance(packet, StaticRoutingPacket):
            self.handle_routing_packet(packet, dynamic=False)
        elif isinstance(packet, DynamicRoutingPacket):
            self.handle_routing_packet(packet, dynamic=True)
        # Route the packet
        elif isinstance(packet, AckPacket) or isinstance(packet, Packet):
            if not routing_table:
                Logger.warning(time, "%s dropped packet %s, no routing table. "
                                     "Creating one now." % (self, packet))
                self.create_routing_table(self.dynamicEnabled)
                return
            elif packet.dest.id not in routing_table:
                # TODO: should we keep a packet queue for packets w/o dest.?
                Logger.warning(time, "%s dropped packet %s, dest. not in "
                                     "routing table." % (self, packet))
                return
            dest_link = routing_table[packet.dest.id].link
            self.send(packet, dest_link, time)
        else:
            raise UnhandledPacketType

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
    def handle_receive(self, packet, time):
        if isinstance(packet, AckPacket):
            Rn = packet.request_number

            self.last_n_req_nums.append(Rn)
            if len(self.last_n_req_nums) > TCPReno.MAX_DUPLICATES:
                self.last_n_req_nums.pop(0)

            Sn, Sb, Sm = self.host.sequence_nums
            cwnd = self.host.cwnd
            if self.last_drop is None or \
               time - self.last_drop > TCPReno.TIMEOUT_TOLERANCE:
                if len(self.last_n_req_nums) == TCPReno.MAX_DUPLICATES and \
                   all(num == Rn for num in self.last_n_req_nums):
                    # If we've had duplicate ACKs, then enter fast retransmit.
                    self.ssthresh = max(self.host.cwnd / 2, TCPReno.INITIAL_CWND)
                    self.set_window_size(time, self.ssthresh)
                    Logger.warning(time, "Duplicate ACKs received for flow %s." % self.host.flow[0])

                    self.last_drop = time
            if self.ss:
                self.set_window_size(time, cwnd + 1)
                if self.host.cwnd >= self.ssthresh:
                    self.ss = False
                    Logger.info(time, "SS phase over for Flow %s. CA started." % (self.host.flow[0]))
            elif Rn > Sb:
                # If we are in Congestion Avoidance mode, we wait for an RTT to
                # increase the window size, rather than doing it on ACK.
                self.set_window_size(time, cwnd + 1. / cwnd)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
    def timeout(self, time, packet):
        """
        A timeout occurred at the given time on the given packet. Resend if
        necessary.

        :param time: Time to resend the packet
        :type time: int
        :param packet: Packet which timed out
        :type packet: Packet
        """
        # We already received an Ack for it
        if packet.id not in self.awaiting_ack:
            return
        else:
            # Otherwise, remove it so that it will be added again
            del self.awaiting_ack[packet.id]

        if not isinstance(packet, FlowPacket):
            # If an ACK packet is dropped, don't worry about it, it'll be sent
            # again later
            return
        flow_id = packet.flow_id
        if self.current_request_num is not None and \
              packet.sequence_number < self.current_request_num:
            # Packet was already received
            return

        self.congestion_control.handle_timeout(packet, time)

        # Resend
        Logger.info(time, "Packet %s was dropped, resending" % (packet.id))
        self.queue.add(packet)
        self.send_packets(time, flow_id)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
 def handle_receive(self, packet, time):
     if isinstance(packet, AckPacket):
         Rn = packet.request_number
         Sn, Sb, Sm = self.host.sequence_nums
         cwnd = self.host.cwnd
         if self.ss:
             self.set_window_size(time, cwnd + 1)
             if self.host.cwnd >= self.ssthresh:
                 self.ss = False
                 Logger.info(time, "SS phase over for Flow %s. CA started." % (self.host.flow[0]))
         elif Rn > Sb:
             # If we are in Congestion Avoidance mode, we wait for an RTT to
             # increase the window size, rather than doing it on ACK.
             self.set_window_size(time, cwnd + 1. / cwnd)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
    def send(self, packet, link, time):
        """
        Sends the given packet along the link at the specified time

        :param packet: Packet to send
        :type packet: Packet
        :param link: Link to send the packet through
        :type link: Link
        :param time: Time to send the packet
        :type time: float
        :return: Nothing
        :rtype: None
        """
        assert len(self.links) > 0, "Can't send if links aren't connected"
        Logger.info(time, "%s sent packet %s over link %s."
                    % (self, packet, link.id))
        # Send the packet
        self.dispatch(PacketSentToLinkEvent(time, self, packet, link))

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]

#.........这里部分代码省略.........
                    i -= 1
                pairs.add(pair)
            except IndexError:
                raise AssertionError('line {} is incorrect!'.format(line))
        return pairs

    def exclude_untracked_videos(self, pairs):
        ids = set(self.db_handler.get_all_video_ids())
        pairs_set = set(pairs)
        for pair in pairs:
            for youtube_id in pair:
                if youtube_id not in ids:
                    pairs_set.remove(pair)
                    break
        return pairs_set

    def rewrite_pairs(self, pairs):
        pairs_fixed = self.exclude_untracked_videos(pairs)
        f = open(self.cfg['train_fixed_path'], 'wb')
        for pair in pairs_fixed:
            f.write(','.join(pair) + '\n')
        f.close()

    def fill_video_catalog(self, pairs, force=False):
        lefts_and_rights = zip(*pairs)
        ids = set(lefts_and_rights[0] + lefts_and_rights[1])

        if not force:
            ids_cache = set(self.db_handler.get_all_video_ids())
            ids.difference_update(ids_cache)

        for i, youtube_id in enumerate(ids):
            if i % 100 == 0:
                self.logger.info('scanned {} lines.'.format(i))
            self.add_video_by_id(youtube_id)

    def update_video_catalog(self, limit=None):
        ids_cache = set(self.db_handler.get_all_video_ids())
        for i, youtube_id in enumerate(ids_cache):
            if limit and i > limit:
                break
            self.update_video_by_id(youtube_id)

    def add_video_by_id(self, youtube_id):
        html = self.downloader.get_html(youtube_id)
        if not self.parser._check_video_availability(html):
            return

        video_item = Video(youtube_id)
        video_item.update(title=self.parser.get_video_title(html))
        self.db_handler.add_entry(video_item)

    def update_video_by_id(self, youtube_id):
        html = self.downloader.get_html(youtube_id)
        if not self.parser._check_video_availability(html):
            return

        video_item = self.db_handler.get_video_by_youtube_id(youtube_id)
        try:
            video_item.update(
                title=self.parser.get_video_title(html),
                views=self.parser.get_view_count(html),
                likes=self.parser.get_likes_count(html),
                dislikes=self.parser.get_dislikes_count(html),
            )
        except ParseError:

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
from config import JOBSTORES, EXECUTORS, JOB_DEFAULTS, LOGGER, LOG_TO
from utils import Logger

app = Flask(__name__)
app.config.from_object('config')

if not os.path.exists(LOG_TO):
    os.makedirs(LOG_TO)

fh = logging.FileHandler(os.path.join(LOG_TO, LOGGER.get('file')))
fh.setLevel(LOGGER.get('level'))
fh.setFormatter(LOGGER.get('formatter'))

log = Logger("Roller", fh)

log.info("Service started!")

sched_log = Logger("apscheduler.executors.default", fh)
sched_log_jobstore = Logger("apscheduler.jobstores.default", fh)

scheduler = BackgroundScheduler(jobstores=JOBSTORES, executors=EXECUTORS, job_defaults=JOB_DEFAULTS, timezone=utc)
scheduler.start()

log.info("Scheduler started!")


def onstop():
    # Shut down the scheduler when exiting the app
    scheduler.shutdown()
    log.info("Scheduler shutdown")
    log.info("Service stopped!")

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
 def execute(self):
     Logger.info(self.time, "Packet %s sent over link %s to %s" % (self.packet, self.link.id, self.destination))
     transmission_delay = self.link.transmission_delay(self.packet)
     recv_time = self.time + transmission_delay + self.link.delay
     self.link.packets_on_link[self.link.get_direction_by_node(self.destination)].append(self.packet)
     self.link.dispatch(PacketReceivedEvent(recv_time, self.packet, self.destination, self.link))

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
 def execute(self):
     Logger.info(self.time, "Packet %s sent to link %s from %s" % (self.packet, self.link.id, self.origin))
     self.link.send(self.time, self.packet, self.origin)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
class RTC(object):
	def __init__(self, dev=None, enable_ems=False):
		self.dev = dev
		self.logger = Logger('RTC')

		self.can_id = None  # todo need to be further confirm
		self.task = None

		self.ui_queue = None
		self.db = None

		self.enable_ems = enable_ems
		self.ems_data = Data() if self.enable_ems else None

		self.scheduler = BackgroundScheduler(daemon=True)
		self.set_scheduler()

	def api(self, cmd, parameters):
		self.logger.info('Real-Time Controller api() ' + ' ' + cmd + ' ' + json.dumps(parameters))

		if cmd == 'TURN_OFF':
			self.turn_off()
		elif cmd == 'TURN_ON':
			self.turn_on()

	def contingency_analysis_classifier(self, can_message):
		pass

	def turn_off(self):
		self.logger.info('TURNING OFF module')

	def turn_on(self):
		self.logger.info('TURNING ON module')
		if self.task is None:
			self.task = TurnOn(self, timeout=15)
		else:
			return False

	def hi(self):
		print(ctime(time()), end='\r', flush=True)
		if self.task is not None:
			self.task.state.spent_t += 0.5
			self.task.spent_t += 0.5
			self.task.run()

			if self.task.spent_t > self.task.TIMEOUT:
				self.logger.error('Task ' + self.task.name + ' fail...')
				self.task = None

	def get_ems_data(self):

		results_dispatch = self.db.query(DispatchDBData).limit(2)
		results_unit = self.db.query(UnitsDBData).limit(2)
		results_forecast = self.db.query(ForecastDBData).limit(2)

		# todo process every line of result and send to GUI

		for d in results_dispatch:
			res = d.__dict__
			res.pop('_sa_instance_state')
			res['datetime1'] = mktime(d.datetime1.timetuple()) + d.datetime1.microsecond / 1000000.0

			self.ems_data.update(res)
			self.ui_queue.put(self.ems_data)

	def set_scheduler(self):
		self.scheduler.add_job(self.hi, 'interval', seconds=0.5)
		if self.enable_ems:
			if self.db is None:
				self.db = db_session()
			self.scheduler.add_job(self.get_ems_data, 'interval', seconds=1)

		self.scheduler.start()

	def is_bic_online(self):
		for dev in self.dev['bic']:
			if not dev.is_connected():
				self.logger.error((dev.name, ' is not online'))
				return False
		return True

	def minimum_system_online(self):

		for dev in self.dev['battery']:
			if not dev.is_connected():
				self.logger.error((dev.name, ' is not online'))
				return False

		for dev in self.dev['rm']:
			if not dev.is_connected():
				self.logger.error((dev.name, ' is not online'))
				return False

		return True

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
from utils import Logger

VERSION="1.0.0"

class MyHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    def get(self):
        def __callback(response):
            data = { 'body': response.body[:20] + '...', 'length' : len(response.body) }
            self.set_header('Content-Type', 'application/json; charset="utf-8"')
            self.write(json.dumps(data))
            self.finish()

        async_client = tornado.httpclient.AsyncHTTPClient()
        request = tornado.httpclient.HTTPRequest("http://www.uol.com.br/")
        async_client.fetch(request, __callback) 

application = tornado.web.Application([
    (r"/", MyHandler),
])

global logger
global http_server    

if __name__ == "__main__":
    tornado.options.parse_command_line()
    logger = Logger('info', False)    
    logger.info('starting webasync v%s' % VERSION)    
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
 def execute(self):
     Logger.info(self.time, "Packet %s received at %s" % (self.packet, self.destination))
     self.destination.receive(self.packet, self.time)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
 def set_window_size(self, time, value):
     flow_id = self.flow[0]
     Logger.info(time, "Window size changed from %0.2f -> %0.2f for flow %s" % (self.cwnd, value, flow_id))
     self.cwnd = value
     self.dispatch(WindowSizeEvent(time, flow_id, self.cwnd))

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import info [as 别名]
    def receive(self, packet, time):
        """
        Handles receipt of a packet.

        :param packet: Packet received
        :type packet: Packet | AckPacket
        :param time: Time the packet was received
        :type time: int
        :return: Nothing
        :rtype: None
        """
        Logger.info(time, "%s received packet %s." % (self, packet))
        # Ack packet, drop stored data that might need retransmission
        if isinstance(packet, AckPacket):
            flow_id = packet.flow_id
            Rn = packet.request_number

            if self.current_request_num is None:
                self.current_request_num = Rn
            else:
                self.current_request_num = max(Rn, self.current_request_num)

            # Receiving request number Rn means every packet with sequence
            # number <= Rn - 1 was received, so those have been acked. No need
            # to wait for their ack or to resend.
            acked_packets = []
            for packet_id, packet_data in self.awaiting_ack.items():
                acked_packet, _ = packet_data
                if acked_packet.sequence_number < Rn:
                    acked_packets.append(packet_id)
            for acked_packet_id in acked_packets:
                acked_packet, sent_time = self.awaiting_ack[acked_packet_id]
                if acked_packet in self.queue:
                    self.queue.remove(acked_packet)
                del self.awaiting_ack[acked_packet_id]
                self.dispatch(RTTEvent(flow_id, time, time - sent_time))

            self.congestion_control.handle_receive(packet, time)

            Sn, Sb, Sm = self.sequence_nums
            if Rn > Sb:
                Sm = Sm + (Rn - Sb)
                Sb = Rn
                Sn = Sb
                self.send_packets(time, flow_id)
            self.sequence_nums = (Sn, Sb, Sm)

        elif isinstance(packet, RoutingPacket):
            return
        # Regular packet, send acknowledgment of receipt
        elif isinstance(packet, FlowPacket):
            if packet.flow_id not in self.request_nums:
                self.request_nums[packet.flow_id] = 0
            if packet.sequence_number == self.request_nums[packet.flow_id]:
                Logger.warning(time, "Packet %d accepted from %s" % (packet.sequence_number, packet.src))
                self.request_nums[packet.flow_id] += 1
            else:
                Logger.info(time, "Incorrect packet received from %s. Expected %d, got %d." % (packet.src, self.request_nums[packet.flow_id], packet.sequence_number))
            ack_packet = AckPacket(packet.flow_id, self, packet.src, self.request_nums[packet.flow_id], packet)
            self.send(ack_packet, time)
        # Ignore routing packets
        else:
            raise UnhandledPacketType