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()
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()
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
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()
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
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()
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()
def execute(paramsDictionary, message): remoteAddress = paramsDictionary["CLIENT_ADDRESS"] logger.logImportant(NAME+ "Wykryto odlaczenie serwera " + remoteAddress) file = FileProcessor(paramsDictionary["HOME_PATH"]+"ServerSide/config/addresses.conf") if( paramsDictionary["CONNECTION_MODE"] == True ): paramsDictionary["CONNECTION"]._socket.close() logger.logInfo(NAME+ "Proba zapisu do pliku adresowego") writeOk = False while writeOk != True: try: file.lockFile() logger.logInfo(NAME + "Plik adresowy zablokowany") writeOk = True addresses = file.readFile() addresses[paramsDictionary["CLIENT_ADDRESS"]] = 'F' file.writeToFile(addresses) file.unlockFile() logger.logInfo(NAME+ "Plik adresowy zaktualizowany") if file.lock.is_locked: file.unlockFile() except Exception, e: logger.logError(NAME + "Nie mozna zablokowac pliku adresowego, czekanie bedzie wznowione")
logger.logError(NAME + e.message)
file.unlockFile()
return apache.HTTP_OK
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.logImportant(NAME+ "Polaczenie z " + paramsDictionary["CLIENT_ADDRESS"] + " nawiazane")
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 cyklicznych, zamykanie polaczenia")
logger.logError(NAME + e.message)
for singleModule in modules["HOST_DC"]:
singleModule.execute(paramsDictionary, None)
return apache.HTTP_OK
paramsDictionary["DB_PARAMS"] = dbParamsDict
login = dbParamsDict["DEFAULT_LOGIN"]
password = dbParamsDict["DEFAULT_PASSWORD"]
else:
logger.logError(NAME + "Brak serwerow, od ktorych mozna pobrac aktualne dane")
return
except Exception, e:
logger.logError(NAME + e.message)
if lock.is_locked:
lock.release()
try:
db = MySQLdb.connect(dbParamsDict["HOST"], login, password, dbParamsDict["DATABASE"])
cursor = db.cursor()
logger.logImportant(NAME + "Rozpoczynanie uspojniania danych")
while version != END_MESSAGE:
command = connection.get_message()
logger.logImportant(NAME + "Wykonuje: " + command )
cursor.execute(command)
command = command.replace('\'', '\\\'')
logger.logInfo(NAME + "Komenda po transformacji " + command)
insert = "INSERT INTO " + dbParamsDict["versionsTableName"] + " VALUES(" + str(version) + ",\'" + command + "\')"
logger.logInfo(NAME + "Wykonuje: " + insert)
cursor.execute(insert)
logger.logInfo(NAME + "wykonano inserta")
currentVersion = version
version = connection.get_message()
logger.logInfo(NAME + "zamykanie polaczenia z baza danych")
