Python log.info函数代码示例

def mytest(ip, port, username, password):
    domain = ""
    width = 1024
    height = 800
    fullscreen = False
    optimized = False
    recodedPath = None
    keyboardLayout = 'en'
    app = QtGui.QApplication(sys.argv)

    #add qt4 reactor
    import qt4reactor
    qt4reactor.install()

    if fullscreen:
        width = QtGui.QDesktopWidget().screenGeometry().width()
        height = QtGui.QDesktopWidget().screenGeometry().height()

    log.info("keyboard layout set to %s"%keyboardLayout)

    from twisted.internet import reactor
    ret = {"connected": False}
    mytimer = TimerThread(app, reactor, ret)
    mytimer.start()

    reactor.connectTCP(ip, int(port), RDPClientQtFactory(width, height, username, password, domain, fullscreen, keyboardLayout, optimized, "nego", recodedPath, mytimer))
    reactor.runReturn()
    app.exec_()
    return ret["connected"]

 def onReady(self):
     """
     @summary: callback use when RDP stack is connected (just before received bitmap)
     """
     log.info("connected %s"%addr)
     width, height = self._controller.getScreen()
     self._buffer = QtGui.QImage(width, height, QtGui.QImage.Format_RGB32)

    def sendWheelEvent(self, x, y, step, isNegative = False, isHorizontal = False):
        """
        @summary: Send a mouse wheel event
        @param x: x position of pointer
        @param y: y position of pointer
        @param step: number of step rolled
        @param isHorizontal: horizontal wheel (default is vertical)
        @param isNegative: is upper (default down)
        """
        if not self._isReady:
            return

        try:
            event = pdu.data.PointerEvent()
            if isHorizontal:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_HWHEEL
            else:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_WHEEL
                
            if isNegative:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_WHEEL_NEGATIVE
                
            event.pointerFlags.value |= (step & pdu.data.PointerFlag.WheelRotationMask)
            
            #position
            event.xPos.value = x
            event.yPos.value = y
            
            #send proper event
            self._pduLayer.sendInputEvents([event])
            
        except InvalidValue:
            log.info("try send wheel event with incorrect position")

 def onReady(self):
     """
     @summary:  Event use to inform state of server stack
                 First time this event is called is when human client is connected
                 Second time is after color depth nego, because color depth nego
                 restart a connection sequence
     @see: rdp.RDPServerObserver.onReady
     """
     if self._rssFile is None:
         #compute which RSS file to keep
         width, height = self._controller.getScreen()
         size = width * height
         rssFilePath = sorted(self._rssFileSizeList, key = lambda x: abs(x[0][0] * x[0][1] - size))[0][1]
         log.info("select file (%s, %s) -> %s"%(width, height, rssFilePath))
         self._rssFile = rss.createReader(rssFilePath)
     
     domain, username, password = self._controller.getCredentials()
     hostname = self._controller.getHostname()
     log.info("""Credentials:
     \tdomain : %s
     \tusername : %s
     \tpassword : %s
     \thostname : %s
     """%(domain, username, password, hostname));
     self.start()

    def sendPointerEvent(self, x, y, button, isPressed):
        """
        @summary: send pointer events
        @param x: x position of pointer
        @param y: y position of pointer
        @param button: 1 or 2 or 3
        @param isPressed: true if button is pressed or false if it's released
        """
        if not self._isReady:
            return

        try:
            event = pdu.data.PointerEvent()
            if isPressed:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_DOWN
            
            if button == 1:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_BUTTON1
            elif button == 2:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_BUTTON2
            elif button == 3:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_BUTTON3
            else:
                event.pointerFlags.value |= pdu.data.PointerFlag.PTRFLAGS_MOVE
            
            #position
            event.xPos.value = x
            event.yPos.value = y
            
            #send proper event
            self._pduLayer.sendInputEvents([event])
            
        except InvalidValue:
            log.info("try send pointer event with incorrect position")

    def recvData(self, data):
        """
        @summary: Main receive method
        @param data: {Stream} 
        """
        opcode = UInt8()
        data.readType(opcode)
        
        if self.readMCSPDUHeader(opcode.value, DomainMCSPDU.DISCONNECT_PROVIDER_ULTIMATUM):
            log.info("MCS DISCONNECT_PROVIDER_ULTIMATUM")
            self._transport.close()
            return
        
        #client case
        elif not self.readMCSPDUHeader(opcode.value, self._receiveOpcode):
            raise InvalidExpectedDataException("Invalid expected MCS opcode receive data")
        
        #server user id
        per.readInteger16(data, Channel.MCS_USERCHANNEL_BASE)
        
        channelId = per.readInteger16(data)
        
        per.readEnumerates(data)       
        per.readLength(data)
        
        #channel id doesn't match a requested layer
        if not self._channels.has_key(channelId):
            log.error("receive data for an unconnected layer")
            return

        self._channels[channelId].recv(data) 

 def clientConnectionFailed(self, connector, reason):
     """
     @summary: Connection failed event
     @param connector: twisted connector use for rdp connection (use reconnect to restart connection)
     @param reason: str use to advertise reason of lost connection
     """
     self._mytimer.conn_fail()
     log.info("Connection failed : %s"%reason)

 def buildObserver(self, controller, addr):
     """
     @param controller: {rdp.RDPServerController}
     @param addr: destination address
     @see: rdp.ServerFactory.buildObserver
     """
     log.info("Connection from %s:%s"%(addr.host, addr.port))
     return HoneyPotServer(controller, self._rssFileSizeList)

 def clientConnectionFailed(self, connector, reason):
     """
     @summary: Connection failed event
     @param connector: twisted connector use for rdp connection (use reconnect to restart connection)
     @param reason: str use to advertise reason of lost connection
     """
     log.info("Connection failed : %s"%reason)
     reactor.stop()
     app.exit()

 def onKeyEventUnicode(self, code, isPressed):
     """
     @summary: Event call when a keyboard event is catch in unicode format
     @param code: unicode of key
     @param isPressed: True if key is down
     @see: rdp.RDPServerObserver.onKeyEventUnicode
     """
     if not isPressed:
         k.type_string(chr(code))
         log.info("KeyEventUnicode: " + chr(code))

 def onClose(self):
     """
     @summary: callback use when RDP stack is closed
     """
     log.info("save screenshot into %s" % self._path)
     if self._complete:
         if self._dbm:
             self._dbm.open_connection()
             self._dbm.update_vnc_rdp_object(self._obj)
             self._dbm.close()
         self._buffer.save(self._path)

 def clientConnectionFailed(self, connector, reason):
     """
     @summary: Connection failed event
     @param connector: twisted connector use for rfb connection (use reconnect to restart connection)
     @param reason: str use to advertise reason of lost connection
     """
     log.info("connection failed : %s"%reason)
     RFBScreenShotFactory.__INSTANCE__ -= 1
     if(RFBScreenShotFactory.__INSTANCE__ == 0):
         reactor.stop()
         app.exit()

 def clientConnectionFailed(self, connector, reason):
     """
     @summary: Connection failed event
     @param connector: twisted connector use for rdp connection (use reconnect to restart connection)
     @param reason: str use to advertise reason of lost connection
     """
     log.info("connection failed : %s"%reason)
     RDPScreenShotFactory.__STATE__.append((connector.host, connector.port, reason))
     RDPScreenShotFactory.__INSTANCE__ -= 1
     if(RDPScreenShotFactory.__INSTANCE__ == 0):
         self._reactor.stop()
         self._app.exit()

 def recvSecurityResult(self, data):
     """
     Read security result packet
     Use by server to inform connection status of client
     @param data: Stream that contain well formed packet 
     """
     result = UInt32Be()
     data.readType(result)
     if result == UInt32Be(1):
         log.info("Authentification failed")
         if self._version.value == ProtocolVersion.RFB003008:
             self.expectWithHeader(4, self.recvSecurityFailed)
     else:
         log.debug("Authentification OK")
         self.sendClientInit()

 def onPointerEvent(self, x, y, button, isPressed):
     """
     @summary: Event call on mouse event
     @param x: x position
     @param y: y position
     @param button: 1, 2 or 3 button
     @param isPressed: True if mouse button is pressed
     @see: rdp.RDPServerObserver.onPointerEvent
     """
     if isPressed:
         m.press(x, y, button)
         time.sleep(0.05)
         m.release(x, y)
     else:
         m.move(x, y)
     log.info("PointerEvent: " + str(x) + " " + str(y) + " @" + datetime.now().strftime("%Y-%m-%d %H:%M:%S"))