本文整理汇总了Python中utils.Logger.logError方法的典型用法代码示例。如果您正苦于以下问题:Python Logger.logError方法的具体用法?Python Logger.logError怎么用?Python Logger.logError使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类utils.Logger
的用法示例。
在下文中一共展示了Logger.logError方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: web_socket_transfer_data
# 需要导入模块: 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
示例2: execute
# 需要导入模块: 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
示例3: run
# 需要导入模块: 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 )
示例4: execute
# 需要导入模块: 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()
示例5: web_socket_transfer_data
# 需要导入模块: 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
示例6: startTransaction
# 需要导入模块: 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
示例7: executeTransaction
# 需要导入模块: 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])
示例8: web_socket_transfer_data
# 需要导入模块: 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
示例9: prepare
# 需要导入模块: 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()
示例10: globalAbort
# 需要导入模块: 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()
示例11: web_socket_transfer_data
# 需要导入模块: 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
示例12: execute
# 需要导入模块: 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
示例13: authConnectionMode
# 需要导入模块: 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()
示例14: globalCommit
# 需要导入模块: 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()
示例15: insertNewDataVersions
# 需要导入模块: 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()