Python logger.info函数代码示例

 def __init__(self, path=None, name=None, egg=None):
   '''
   Try to register a new plugin.
   
   @path=Path to the plugin
   @name=Name of the plugin it self
   @egg=True if the plugin is stored into an egg file
   '''
   if not egg:
     self.path = os.path.join(path, name)
   else:
     self.path = path
   if not egg:
     self.name = 'plugins.%s' % name
   else:
     self.name = name
   self.egg = egg
   if not self.egg:
     self.__loadFromFile(self.path)
   else:
     self.__loadFromEgg(self.path)
   self.enabled = self.provides.get('enabled', False)
   self.__module = None
   self.__version = None
   self.__version_info = None
   self.__rpc = None
   logger.info("Plugin: %s registered" % self.name)

	def endConnection(self, exit=True):
		self.shellPushIntoHistory(time.time())
		
		time.sleep(2)
		if exit:
			logger.info("Sending exit")
			self.shellExit()

    def handle_connection(self, conn, remote):
        request = conn.recv(4096)
        conn.setblocking(0)
        command, url = request.splitlines()[0].split()[:2]
        if command.strip() != "GET":
            conn.shutdown(sk.SHUT_RDWR)
            conn.close()
            return True

        if url.strip() != "/":
            conn.shutdown(sk.SHUT_RDWR)
            conn.close()
            return True

        logger.info("Got a connection to the http stream, redirecting")
        host = ""
        for line in request.splitlines():
            if line.find("Host") > -1:
                host = line.strip().split()[1].split(":", 1)[0]

        conn.sendall("HTTP/1.0 200 OK\r\n")
        conn.sendall("Content-type:multipart/x-mixed-replace; boundary=--myboundary\r\n")
        conn.sendall("\r\n")
        self.clientsockets[remote] = conn
        logger.info("Connection ready for streamming")
        return True

def handle_file_failed(dongle, remote, pending, channel, files, ret, err, services):
    logger.info("handle file failed %s[%s]: %s" % (remote, channel, files))
    logger.debug(err)
    try:
        try_again = []
	rules = get_campaign_rule(files)
        if rules is None or len(rules)==0:
            raise Exception("Couldn't find rule")

        for rule in rules:
            record = save_file_failed(rule, dongle, ret, remote)

    	    # from here we try again either on timeout or if rejected count is 
    	    # smaller than filter
    	    if rule.tryAgain(record=record):
    		try_again.append(rule)

	# if we can't try again this method will raise an exception
	# and the try/catch will make sure the remote device gets out
	# of our pending list
    	if upload_after_rejected(try_again, services, dongle=dongle, remote=remote):
    	    return
    except Exception, err:
        logger.error("OOOPS!!!")
        logger.exception(err)

 def on_disconnect(self):
     a = [ p for p in pending if pending[p]==self]
     if len(a) > 0:
        logger.info("a client disconnected, clearing %s pending transactions" % len(a))
        for p in a:
            pending.pop(p)
     services.remove(self)

    def exposed_setConcurrent(self, val):
	'''
	Exposed method that lets the server tell us if we should do concurrent 
	scanning (all the scanners work at the same time), or sequence scanning.
	'''
        self.concurrent = val
        logger.info("setConcurrent %s" % val)

        def exposed_uploader_register(self, client = None,
    					    remote_quit=None, 
    					    dongles=None):
            global enabled
            all_dongles.update(dongles)
            self.dongles = set()
            self.add_dongle = async(client.add_dongle)
            self.upload = async(client.upload)
            self.remote_quit = async(remote_quit)
            self.refreshUploaders = async(client.refreshUploaders)

            self.uploader = client

            if not enabled:
                return

            if not db_ready():
        	return

            logger.info("uploader register")
            for dongle in dongles:
                self.dongles.add( str(dongle), )

            for dongle, max_conn, name in rpc.uploader.get_dongles(dongles):
                logger.info("%s: %s[%s]" % (dongle, name, max_conn))
                self.add_dongle(dongle, max_conn, name)
            self.refreshUploaders()

def handle_parent(signum, frame):
    '''
    When the parent gets the kill signal it will stop it self no forking more
    childrens.
    '''
    logger.info("Parent killed, doing exit")
    sys.exit(0)

def latest_picture(request):
    try:
	b = models.CameraRecord.objects.latest('time').picture.name
    except:
	b = None
    logger.info(b)
    return HttpResponse( json.dumps({'name': b}), 'application/json')

def handle_adapter_added_or_removed(path, signal):
    '''
    When ever a dongle is added or removed this function gets called, so we can
    restart the rpc client.
    '''
    logger.info("bluez.%s: %s" % (signal, path))
    stop()

def started(scanner, address):
    logger.info('scan_started %s' % address)
    dongle = ScannerBluetoothDongle.objects.get(address=address)
    record = DeviceRecord()
    record.action = signals.CYCLE_SCAN_DONGLE
    record.dongle = dongle
    record.save()

	def disconnect(self, force=False):
	    if not force:
		self.checkConnected("Can't close if it's opened");
	    logger.info("Closing socket");
	    self.socket.shutdown(socket.SHUT_RDWR);
	    self.socket.close()
	    self.socket = None

def handle_sdp_timeout(dongle, remote, pending):
    logger.info("SDP timeout: %s" % remote )
    pending.pop(remote)
    record = RemoteBluetoothDeviceSDPTimeout()
    record.dongle = UploaderBluetoothDongle.objects.get(address=dongle)
    record.setRemoteDevice(remote)
    record.save()

def __restart_server():
    logger.info("restarting server")
    try:
        server = rpyc.connect('localhost', 8010)
        server.root.restart()
    except:
        #could be that we're only running the web server
        pass

    def handle_name_owner_changed(self, own, old, new):
	''' detect if a name owner is gone, this prevents dead locks '''
	if own in self.connections:
	    if new is None or len(new) is 0:
		for client in self.connections[own]:
		    logger.info("%s lost connection, killing it" % client.path)
		    client.force_disconnect()
		self.connections[own] = None