Python Logger.logInfo方法代码示例

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def web_socket_transfer_data(request):
	while True:
		line = request.ws_stream.receive_message()
		logger.logInfo(NAME + "Serwer otrzymal " + line)
		request.ws_stream.send_message(line)
		if line == _GOODBYE_MESSAGE:
			return apache.HTTP_OK

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def web_socket_transfer_data(request):

	logger.logInfo(NAME+ "Server dostal zgloszenie")

	paramsDictionary = {}
	paramsDictionary["SOCKET"] = request.ws_stream
	paramsDictionary["HOME_PATH"] = request.get_options()["PROJECT_LOCATION"]
	paramsDictionary["CLIENT_ADDRESS"] = request.connection.remote_ip
	stopQueue = Queue()
	listenThread = KillableListenThread(request.ws_stream, stopQueue)

	ticket = request.ws_stream.receive_message()
	currentTicket = TicketUtil.readTempVars()[EXPECTED_TICKET]
	timeOut = (int(ticket) - int(currentTicket)) * 5
	start = time.time()
	while currentTicket < ticket and time.time() - start < timeOut:
		time.sleep(1)
		currentTicket = TicketUtil.readTempVars()[EXPECTED_TICKET]
	if currentTicket == ticket:
		request.ws_stream.send_message(OK)
		listenThread.start()
		if listenThread.getMessage(5) != OK:
			skip(paramsDictionary, ticket)
	else:
		request.ws_stream.send_message(ABORT)
		skip(paramsDictionary, ticket)
	stopQueue.put("STOP")
	return apache.HTTP_OK

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def execute(paramsDictionary, message):
	remoteAddress = paramsDictionary["CLIENT_ADDRESS"]

	logger.logImportant(NAME+ "Wykryto probe nawiazania polaczenia od " + remoteAddress)
	file = FileProcessor(paramsDictionary["HOME_PATH"]+"ServerSide/config/addresses.conf")
	paramsDictionary["CONNECTION_MODE"] = False
	try:
		file.lockFile()
		addresses = file.readFile()
		for key in addresses:
			logger.logInfo(NAME+ "klucz %s", key)
			logger.logInfo(NAME+ "adres serwera zdalnego %s", remoteAddress)
			logger.logInfo(NAME+ "addresses[key] %s", addresses[key])
			if key == remoteAddress:
				logger.logInfo(NAME+ "znalazl dopasowanie")
				if( addresses[key] != 'T' ):
					logger.logInfo(NAME+ "proba nawiazania polaczenia z nowododanym serwerem")
					paramsDictionary["CONNECTION"] = Connection(paramsDictionary["HOME_PATH"]+"ServerSide/config/ping_config.conf")
					if paramsDictionary["CONNECTION"].connect(remoteAddress, 80, RESOURCE) != ERROR:
						paramsDictionary["SOCKET"] = paramsDictionary["CONNECTION"]._stream
						paramsDictionary["SOCKET"].send_message(PING)
						paramsDictionary["SOCKET"].receive_message()
						logger.logImportant(NAME+ "Polaczenie z " + remoteAddress + " nawiazane")
						addresses[key] = 'T'
						file.writeToFile(addresses)
						paramsDictionary["CONNECTION_MODE"] = True
				break
	except Exception, e:
		logger.logError(NAME + e.message)
		file.unlockFile()

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def web_socket_transfer_data(request):

    logger.logInfo(NAME + "Server dostal zgloszenie")

    paramsDictionary = {}
    paramsDictionary["SOCKET"] = request.ws_stream
    paramsDictionary["HOME_PATH"] = request.get_options()["PROJECT_LOCATION"]
    methodMapping = {PREPARE: prepare, GLOBAL_COMMIT: globalCommit, GLOBAL_ABORT: globalAbort}
    configReader = ConfigurationReader(
        paramsDictionary["HOME_PATH"] + "ServerSide/config/database_config/database.conf"
    )
    dbParamsDict = configReader.readConfigFile()
    paramsDictionary["DB_PARAMS"] = dbParamsDict
    paramsDictionary["CLIENT_ADDRESS"] = request.connection.remote_ip

    login = request.ws_stream.receive_message()

    password = request.ws_stream.receive_message()

    db = DatabaseConnector(login, password, dbParamsDict["DATABASE"], dbParamsDict["HOST"])

    command = request.ws_stream.receive_message()
    lockFilePath = paramsDictionary["HOME_PATH"] + "ServerSide/config/database_config/dbLock.dat"
    lock = FileLock(lockFilePath, 2, 0.05)
    try:
        while command != EXIT:
            methodMapping[command](paramsDictionary, db, lock)
            command = request.ws_stream.receive_message()
        if lock.is_locked:
            lock.release()
    except Exception, e:
        logger.logError(NAME + e.message)
        if lock.is_locked:
            lock.release()
        return apache.HTTP_OK

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def prepare(paramsDictionary, db, lock):
    logger.logInfo(NAME + "Prepare")
    try:
        socket = paramsDictionary["SOCKET"]
        command = socket.receive_message()
        paramsDictionary["COMMAND"] = command
        logger.logInfo(NAME + "Wezel otrzymal komende do wykonania " + command)
        if db.initConnection() == ERROR:
            logger.logError(NAME + "Nie moge polaczyc sie z baza danych")
            socket.send_message(ABORT)
            if lock.is_locked:
                lock.release()
            return
        lock.acquire()
        if lock.is_locked == False:
            logger.logError(NAME + "Nie moge zalozyc blokady")
            socket.send_message(ABORT)
            lock.release()
            return
        if db.executeQueryWithoutTransaction(command) != OK_CODE:
            socket.send_message(ABORT)
            logger.logError(NAME + "Nie moge wykonac polecenia")
            lock.release()
            return
        logger.logImportant(NAME + "Uczestnik jest gotowy do zaakceptowania operacji")
        socket.send_message(READY_COMMIT)
        return
    except Exception, e:
        logger.logError(NAME + e.message)
        if lock.is_locked:
            lock.release()

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
	def run(self):
		try:
			methodMapping = {PREPARE : self.prepare,
			                 GLOBAL_COMMIT : self.globalCommit,
			                 GLOBAL_ABORT : self.globalAbort}

			self.connection = Connection(self.paramsDictionary["HOME_PATH"]+"ServerSide/config/database_config/transaction_config.conf")
			if self.connection.connect(self.clientAddress, 80, RESOURCE) == OK_FLAG:
				logging.info(NAME + "Polaczenie dla transakcji zapisu nawiazane")
				self.connection.send_message(self.dbLogin)
				self.connection.send_message(self.dbPassword)

				command = self.inputQueue.get(True, None)
				while command != STOP_THREAD:
					methodMapping[command]()
					command = self.inputQueue.get(True, None)
					logger.logInfo(NAME + "Odebrano komende " + command)
				self.connection.send_message(EXIT)
			else:
				logger.logError(NAME + "Nie mozna nawiazac polaczenia dla transakcji zapisu")
				self.outputQueue.put(ABORT)
				self.connection._do_closing_handshake()
			logger.logInfo(NAME + "Konice watku transakcji zapisu")
		except Exception, e:
			logging.error(NAME + e.message )

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def execute(paramsDictionary, message):
	global timer
	if timer == 0:
		timer = int(paramsDictionary["CONFIG_PARAMS"]["passExchangePeriod"])
		logger.logInfo(NAME + "Wysylam zapytanie o stare haslo do " + paramsDictionary["CLIENT_ADDRESS"])
		paramsDictionary["SOCKET"].send_message(RES_MODULE+NEW_PASS)
	else:
		timer = timer -1

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def checkIfServerIsUpToDate(dataVersions):
	myVersion = dataVersions[LOCALHOST_NAME]
	for address in dataVersions:
		logger.logInfo(NAME + "analizuje " + address)
		if int(dataVersions[address]) > int(myVersion):
			logger.logInfo(NAME + "Dane na serwerze nie sa aktualne")
			return False
	return True

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
	def startTransaction(self):
		logger.logInfo(NAME + "StartMethod")
		ticket = self.inputQueue.get(True, None)
		self.connection.send_message(ticket)
		try:
			answer = self.connection.get_message()
		except Exception, e:
			logger.logError(NAME + e.message )
			return

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def execute(paramsDictionary, message):
    logger.logInfo(NAME + "Resetuje stan serwera")
    file = FileProcessor(paramsDictionary["HOME_PATH"] + "ServerSide/config/addresses.conf")
    file.lockFile()
    addresses = file.readFile()
    for key in addresses:
        addresses[key] = "F"
    file.writeToFile(addresses)
    file.unlockFile()

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
 def run(self):
     self.listener.start()
     while self.stopQueue.empty():
         try:
             message = self.internalQueue.get(True, 2)
         except Empty:
             logger.logInfo(NAME + "No message")
             continue
         self.messageQueue.put(message)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def execute(paramsDictionary, message):
	logger.logInfo(NAME + "otrzymalem " + message)
	splited = message.split('%')
	toCall = splited[0]
	if len(splited) > 1:
		argument = splited[1]
	else:
		argument = None
	function = functions[toCall]
	function(paramsDictionary, argument)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
	def dispatch(self, message):
		splited = message.split(':')
		module = splited[0]
		if len(splited) > 1:
			message = splited[1]
		else:
			message = None
		if( self.modules[module] != None ):
			logger.logInfo(NAME+"znaleziono modul odpowiadajacy za obsluge")
			for singleModule in self.modules[module]:
				singleModule.execute(self.paramsDictionary, message)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def web_socket_transfer_data(request):
	logger.logInfo(NAME + "Zgloszenie po bilet od " + str(request.connection.remote_ip))

	homePath = request.get_options()["PROJECT_LOCATION"]
	processor = FileProcessor(homePath + "ServerSide/config/database_config/ticketNumber.dat")
	processor.lockFile()
	number = processor.readFirstLine()
	nextNumber = int(number) + 1
	processor.writeSingleLine(str(nextNumber))
	processor.unlockFile()
	request.ws_stream.send_message(str(nextNumber))
	logger.logInfo(NAME + request.connection.remote_ip + " otrzymal bilet " + str(nextNumber))
	return apache.HTTP_OK

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logInfo [as 别名]
def getOldPassword(paramsDictionary, argument):
	socket = paramsDictionary["SOCKET"]
	remoteAddress = paramsDictionary["CLIENT_ADDRESS"]
	homePath = paramsDictionary["HOME_PATH"]

	logger.logInfo(NAME + "wyszukuje stare haslo")
	processor = FileProcessor(homePath+"ServerSide/config/pass/me_to_all.pass")
	passwords = processor.readFile()
	oldPass = passwords[remoteAddress]

	socket.send_message(RES_MODULE+OLD+"%"+oldPass)
	logger.logInfo(NAME + "wyslalem stare haslo do " + remoteAddress)
	global expectedMessage
	expectedMessage = NEW