Python Logger.logError方法代码示例

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logError [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 logError [as 别名]
def execute(paramsDictionary, message):
	logger.logInfo(NAME + "wewnatrz modulu rozglaszania nowej wersji ")

	homePath = paramsDictionary["HOME_PATH"]

	lock = paramsDictionary["LOCK"]
	if lock.is_locked == False:
		return
	try:
		addressesfile = FileProcessor(paramsDictionary["HOME_PATH"]+"ServerSide/config/addresses.conf")
		addressesfile.lockFile()
		addresses = addressesfile.readFile()
		addressesfile.unlockFile()

		versionsFile = FileProcessor(homePath+"ServerSide/config/database_config/data_version.dat")
		versionsFile.lockFile()
		dataVersions = versionsFile.readFile()
		versionsFile.unlockFile()

		myVersion = dataVersions[LOCALHOST_NAME]
		logger.logInfo(NAME + "Moja wersja danych " + myVersion)
		for address in addresses:
			if addresses[address] == "T":
				logger.logInfo(NAME + "wysylanie wersji do " + address)
				connection = Connection(homePath + "ServerSide/config/connection_config.conf" )
				if connection.connect(address, 80, RESOURCE) == OK_FLAG:
					connection.send_message(myVersion)
					connection._do_closing_handshake()
				else:
					logger.logError(NAME + "Nie moge polaczyc sie z serwerem o adresie " + address)
	except Exception, e:
		logger.logError(NAME + e.message)
		lock.release

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logError [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 logError [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 logError [as 别名]
def web_socket_transfer_data(request):

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

	paramsDictionary = {}
	paramsDictionary["REQUEST"] = request
	paramsDictionary["CLIENT_ADDRESS"]= request.connection.remote_ip
	paramsDictionary["SOCKET"] = request.ws_stream
	paramsDictionary["HOME_PATH"] = request.get_options()["PROJECT_LOCATION"]

	configReader = ConfigurationReader(paramsDictionary["HOME_PATH"]+"ServerSide/config/runParams.conf")
	paramsDictionary["CONFIG_PARAMS"] = configReader.readConfigFile()

	paramsDictionary["SOCKET"].receive_message()

	if paramsDictionary["CLIENT_ADDRESS"] == PARENT_MACHINE_ADDRESS:
		paramsDictionary["SOCKET"].send_message(EXIT)
		return apache.HTTP_OK

	logger.logImportant(NAME+ "Serwer " + paramsDictionary["CLIENT_ADDRESS"] + " probuje nawiazac polaczenie")

	remoteAddress = paramsDictionary["CLIENT_ADDRESS"]

	file = FileProcessor(paramsDictionary["HOME_PATH"]+"ServerSide/config/addresses.conf")
	paramsDictionary["CONNECTION_MODE"] = True
	try:
		file.lockFile()
		addresses = file.readFile()

		for key in addresses:
			logger.logInfo(NAME+ "klucz %s " + key)
			logger.logInfo(NAME+ "adres zdalnej maszyny %s " + remoteAddress)
			logger.logInfo(NAME+ "addresses[key] %s " + addresses[key])
			if key == remoteAddress:
				if addresses[key] == 'F':
					logger.logInfo(NAME+ "znalazl dopasowanie")
					paramsDictionary["SOCKET"].send_message(PONG)
					logger.logInfo(NAME+ "Server odpowiedzial PONG do " + paramsDictionary["CLIENT_ADDRESS"])
					logger.logInfo(NAME+ "proba nawiazania polaczenia z nowododanym serwerem")
					paramsDictionary["CONNECTION"] = Connection(paramsDictionary["HOME_PATH"]+"ServerSide/config/connection_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.logInfo(NAME+ "nawiazywanie polaczenia z nowododanym serwerem")
						addresses[key] = 'T'
						file.writeToFile(addresses)
						break
				else:
					paramsDictionary["SOCKET"].send_message(EXIT)
					logger.logInfo(NAME+ "Server odpowiedzial EXIT do " + paramsDictionary["CLIENT_ADDRESS"])
					file.unlockFile()
					return apache.HTTP_OK
		file.unlockFile()
	except Exception, e:
		logger.logError(NAME + e.message)
		file.unlockFile()
		return apache.HTTP_OK

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logError [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 logError [as 别名]
	def executeTransaction(self, cursor, command):
		try:
			if self.checkActiveServersCount() == True and self.checkDataVersions() == True:
				cursor.execute(command)
				return cursor.fetchall()
			else:
				return ERROR_MESSAGE
		except MySQLdb.Error, e:
			logger.logError(NAME + "%d %s" % (e.args[0], e.args[1]))
			return "%d %s" % (e.args[0], e.args[1])

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

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

	paramsDictionary = {}
	paramsDictionary["REQUEST"] = request
	paramsDictionary["CLIENT_ADDRESS"]= request.connection.remote_ip
	paramsDictionary["SOCKET"] = request.ws_stream
	paramsDictionary["HOME_PATH"] = request.get_options()["PROJECT_LOCATION"]
	paramsDictionary["CONNECTION_MODE"] = False

	configReader = ConfigurationReader(paramsDictionary["HOME_PATH"]+"ServerSide/config/runParams.conf")
	paramsDictionary["CONFIG_PARAMS"] = configReader.readConfigFile()

	paramsDictionary["SOCKET"].receive_message()
	logger.logInfo(NAME+ "Server otrzymal ping od " + paramsDictionary["CLIENT_ADDRESS"])
	paramsDictionary["SOCKET"].send_message(PONG)
	logger.logInfo(NAME+ "Server odpowiedzial do " + paramsDictionary["CLIENT_ADDRESS"])

	loader = ModulesLoader()
	modules = loader.loadModules(paramsDictionary["HOME_PATH"]+"ServerSide/config/modules.ext")
	paramsDictionary["MODULES"] = modules
	logger.logInfo(NAME+ "Serwer wczytal moduly")

	if modules.has_key("NEW_CONN"):
		for singleModule in modules["NEW_CONN"]:
			singleModule.execute(paramsDictionary, None)

	paramsDictionary["QUEUE"] = Queue.Queue(0)

	logger.logInfo(NAME+ "Serwer rozpoczyna pingowanie")
	listener = ListenSocket(paramsDictionary, modules)
	listener.setDaemon(True)
	listener.start()
	while(True):
		try:
			for singleModule in modules["PERIODIC"]:
				singleModule.execute(paramsDictionary, None)
			time.sleep(int(paramsDictionary["CONFIG_PARAMS"]["singlePeriod"]))
		except Exception, e:
			logger.logError(NAME+ "ERROR w modulach okresowych, zamykanie polaczenia")
			logger.logError(NAME + e.message)
			for singleModule in modules["HOST_DC"]:
				singleModule.execute(paramsDictionary, None)
			logger.logInfo(NAME + "Polaczenie zakonczone")
			return apache.HTTP_OK



			#1000100100000000 - Ping frame in binary with no data
			#1000101000000000 - Pong frame in binary with no data

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logError [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 logError [as 别名]
def globalAbort(paramsDictionary, db, lock):
    try:
        socket = paramsDictionary["SOCKET"]
        logger.logImportant(NAME + "Orzymano polecenie GLOBAL_ABORT")
        db.executeQueryWithoutTransaction(ROLLBACK)
        ticket = socket.receive_message()
        TicketUtil.skipTicket(ticket)
        socket.send_message(OK)
        if lock.is_locked:
            lock.release()
    except Exception, e:
        logger.logError(NAME + e.message)
        if lock.is_locked:
            lock.release()

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

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

	paramsDictionary = {}
	paramsDictionary["REQUEST"] = request
	paramsDictionary["CLIENT_ADDRESS"]= request.connection.remote_ip
	paramsDictionary["SOCKET"] = request.ws_stream
	paramsDictionary["HOME_PATH"] = request.get_options()["PROJECT_LOCATION"]

	configReader = ConfigurationReader(paramsDictionary["HOME_PATH"]+"ServerSide/config/database_config/database.conf")
	dbParamsDict = configReader.readConfigFile()
	paramsDictionary["DB_PARAMS"] = dbParamsDict

	login = request.ws_stream.receive_message()
	password = request.ws_stream.receive_message()
	paramsDictionary["LOGIN"] = login
	paramsDictionary["PASSWORD"] = password


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

	if db.initConnection() == ERROR:
		request.ws_stream.send_message("Invalid username or password")
		logger.logError(NAME + "Uzytkownik podal niewlasciwy login lub haslo, zamykanie polaczenia")
		return apache.HTTP_OK
	logger.logInfo(NAME + "polaczenie z baza nawiazane")
	lockFilePath = paramsDictionary["HOME_PATH"]+"ServerSide/config/database_config/dbLock.dat"
	lock = FileLock(lockFilePath)
	while(True):
		try:
			query = request.ws_stream.receive_message()
			if query == CLOSING_MESSAGE:
				db.closeConnection()
				return apache.HTTP_OK
			else:
				logger.logImportant(NAME + "Klient chce wykonac zapytanie " + query)
				lock.acquire()
				output = db.executeSQL(query, paramsDictionary)
				lock.release()
				logger.logImportant(NAME + str(output))
				request.ws_stream.send_message(str(output))

		except Exception, e:
			logger.logError(NAME + "ERROR w trakcie odbierania wiadomosci " + e.message)
			db.closeConnection()
			if lock.is_locked:
				lock.release()
			return apache.HTTP_OK

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

	if "LOCK" in paramsDictionary:
		lock = paramsDictionary["LOCK"]
	else:
		lockFilePath = paramsDictionary["HOME_PATH"]+"ServerSide/config/database_config/dbLock.dat"
		lock = FileLock(lockFilePath,2,.05)
		paramsDictionary["LOCK"] = lock

	try:
		lock.acquire()
	except Exception, e:
		logger.logError(NAME + e.message)
		if lock.is_locked:
			lock.release()
		return

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logError [as 别名]
def authConnectionMode(paramsDictionary):
	remoteAddress = paramsDictionary["CLIENT_ADDRESS"]
	logger.logInfo(NAME + "Uwierzytelnianie serwera " + remoteAddress)
	socket = paramsDictionary["SOCKET"]
	homePath = paramsDictionary["HOME_PATH"]
	logger.logInfo(NAME + "przed wyslaniem zapytania o haslo")
	socket.send_message(GET_PASSWORD)
	logger.logInfo(NAME + "Oczekiwanie na haslo od serwera")
	password = socket.receive_message()

	logger.logInfo(NAME + "Otrzymano haslo od " + remoteAddress)
	processor = FileProcessor(homePath+"ServerSide/config/pass/all_to_me.pass")
	passwords = processor.readFile()
	logger.logInfo(NAME + "spodziewane haslo " + passwords[remoteAddress] + " otrzymano " + password )
	if(passwords[remoteAddress] == password ):
		logger.logImportant(NAME + "Serwer " + remoteAddress + " uwierzytelniony")

		socket.send_message(PASSWORD_OK)

		logger.logInfo(NAME + "czekam na zapytanie o haslo")

		message = socket.receive_message()

		if  message == GET_PASSWORD:
			processor = FileProcessor(homePath+"ServerSide/config/pass/me_to_all.pass")
			passwords = processor.readFile()
			logger.logInfo(NAME + "Wysylam swoje haslo do " + remoteAddress)

			socket.send_message(passwords[remoteAddress])

			message = socket.receive_message()

		if message == PASSWORD_OK:
			logger.logInfo(NAME + "Haslo zaakceptowane przez " + remoteAddress)
			pass
		else:
			logger.logError(NAME + "Haslo pzeslane przez " + remoteAddress + " niezgodne, zamykanie polaczenia")
			paramsDictionary["CONNECTION"]._socket.close()
	else:
		logger.logError(NAME + "Haslo pzeslane przez " + remoteAddress + " niezgodne, zamykanie polaczenia")
		socket.send_message(WRONG_PASSWORD)
		paramsDictionary["CONNECTION"]._socket.close()

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logError [as 别名]
def globalCommit(paramsDictionary, db, lock):
    try:
        socket = paramsDictionary["SOCKET"]
        servers = socket.receive_message()
        logger.logInfo(NAME + "Mam serwery " + servers)
        servers = servers.split(":")
        servers.append(paramsDictionary["CLIENT_ADDRESS"])
        logger.logImportant(NAME + "Uczestnik zaakceptowal operacje")
        db.executeQueryWithoutTransaction(generateInsertToDataVersions(paramsDictionary))
        db.executeQueryWithoutTransaction(COMMIT)
        insertNewDataVersions(servers, paramsDictionary)
        ticket = socket.receive_message()
        TicketUtil.setNextExpectedTicket(ticket)
        socket.send_message(OK)
        if lock.is_locked:
            lock.release()
    except Exception, e:
        logger.logError(NAME + e.message)
        if lock.is_locked:
            lock.release()

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import logError [as 别名]
def insertNewDataVersions(serversList, paramsDictionary):
    try:
        homePath = paramsDictionary["HOME_PATH"]
        logger.logInfo(NAME + "Metoda wstawiajaca wiersz do tabeli z wierszami")
        versionProcessor = FileProcessor(homePath + "ServerSide/config/database_config/data_version.dat")
        versionProcessor.lockFile()
        logger.logInfo(NAME + "Plik z wersjami zablokowany")
        logger.logInfo(NAME + "Zapisywanie do pliku z wersjami")
        versions = versionProcessor.readFile()
        newVersion = str(int(versions[LOCALHOST_NAME]) + 1)
        for address in serversList:
            logger.logInfo(NAME + "Dla adresu: " + address)
            if address in versions:
                versions[address] = newVersion
                logger.logInfo(NAME + "Zapisano " + address)
        versions[LOCALHOST_NAME] = newVersion
        versionProcessor.writeToFile(versions)
        versionProcessor.unlockFile()
    except Exception, e:
        logger.logError(NAME + e.message)
        versionProcessor.unlockFile()