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
class WriteTransactionThread(Thread): outputQueue = None inputQueue = None eventVariable = None clientAddress = None commands = [] def __init__(self, outputQueue, inputQueue, eventVariable, paramsDictionary, address): Thread.__init__(self) self.clientAddress = address self.inputQueue = inputQueue self.eventVariable = eventVariable self.outputQueue = outputQueue self.paramsDictionary = paramsDictionary self.connection = None self.dbLogin = paramsDictionary["LOGIN"] self.dbPassword = paramsDictionary["PASSWORD"] 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 )
class DelayedTransactionThread(Thread): outputQueue = None inputQueue = None eventVariable = None clientAddress = None commands = [] def __init__(self, outputQueue, inputQueue, eventVariable, paramsDictionary, address): Thread.__init__(self) self.clientAddress = address self.inputQueue = inputQueue self.eventVariable = eventVariable self.outputQueue = outputQueue self.paramsDictionary = paramsDictionary self.connection = None def run(self): try: methodMapping = {SKIP : self.skip, START : self.startTransaction, OK : self.ok} self.connection = Connection(self.paramsDictionary["HOME_PATH"]+"ServerSide/config/connection_config.conf") if self.connection.connect(self.clientAddress, 80, RESOURCE) == OK_FLAG: logger.logInfo(NAME + "Polaczenie z uczestnikiem transakcji " + self.clientAddress + " nawiazane" ) 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 z " + self.clientAddress) self.outputQueue.put(ABORT) self.connection._do_closing_handshake() logger.logInfo(NAME + "Koordynator konczy polaczenie z " + self.clientAddress) except Exception, e: logger.logError(NAME + e.message )
def web_socket_transfer_data(request): paramsDictionary = {} paramsDictionary["REQUEST"] = request paramsDictionary["SOCKET"] = request.ws_stream paramsDictionary["HOME_PATH"] = request.get_options()["PROJECT_LOCATION"] loader = ModulesLoader() modules = loader.loadModules(paramsDictionary["HOME_PATH"]+"ServerSide/config/modules.ext") paramsDictionary["MODULES"] = modules logger.logInfo(NAME+ "Serwer wczytal moduly") configReader = ConfigurationReader(paramsDictionary["HOME_PATH"]+"ServerSide/config/runParams.conf") runParams = configReader.readConfigFile() if modules.has_key("BEFORE_CONNECT"): for singleModule in modules["BEFORE_CONNECT"]: singleModule.execute(paramsDictionary, None) firstTimeIteration = True file = FileProcessor(paramsDictionary["HOME_PATH"]+"ServerSide/config/addresses.conf") while True: if modules.has_key("BEFORE_CONNECT_PERIODIC"): for singleModule in modules["BEFORE_CONNECT_PERIODIC"]: singleModule.execute(paramsDictionary, None) try: file.lockFile() addresses = file.readFile() file.unlockFile() for key in addresses: try: file.lockFile() tempAddresses = file.readFile() if( tempAddresses[key] == 'F' ): connection = Connection(request.get_options()["PROJECT_LOCATION"]+"ServerSide/config/connection_config.conf") if( connection.connect(key,80, RESOURCE) != ERROR ): logger.logInfo(NAME+ "Polaczenie z " + key + " nawiazane") connection.send_message(PING) logger.logInfo(NAME+ "Wysylanie pingu z metody startowej") expectedPong = connection.get_message() logger.logInfo(NAME + "Oczekiwano PONG, Otrzymano " + expectedPong) if expectedPong == PONG: logger.logInfo(NAME+ "Metoda startowa otrzymala odpowiedz, zamykanie polaczenia") connection._do_closing_handshake() logger.logInfo(NAME + "########### polaczenie zakonczone, zapisywanie pliku adresowego") tempAddresses[key] = 'T' file.writeToFile(tempAddresses) logger.logInfo(NAME + "Zapisano zmiany do pliku adresowego") else: logger.logError(NAME+ "Serwer " + key + " nie odpowiedzial na PING, zrywanie polaczenia") else: logger.logError(NAME+ "Nie moge polaczyc sie z " + key) file.unlockFile() except Exception, e: logger.logError(NAME + e.message) file.unlockFile() except Exception, e: logger.logError(NAME + e.message) file.unlockFile() continue file.unlockFile() if firstTimeIteration == True: firstTimeIteration = False if modules.has_key("AFTER_CONNECT"): for singleModule in modules["AFTER_CONNECT"]: singleModule.execute(paramsDictionary, None) if modules.has_key("AFTER_CONNECT_PERIODIC"): for singleModule in modules["AFTER_CONNECT_PERIODIC"]: singleModule.execute(paramsDictionary, None) logger.logInfo(NAME+ "Serwer rozpoczyna czeanie na kolejna ture sprawdzania") time.sleep(int(runParams["ConnectionCheckPeriod"])) logger.logInfo(NAME+ "Serwer wznawia sprawdzanie")
except MySQLdb.Error, e: logger.logError("%d %s" % (e.args[0], e.args[1])) cursor.execute("rollback") except Exception, ee: logger.logError(ee.message) cursor.execute("rollback") if lock.is_locked: lock.release() versionsFile.lockFile() dataVersions = versionsFile.readFile() dataVersions[LOCALHOST_NAME] = currentVersion versionsFile.writeToFile(dataVersions) versionsFile.unlockFile() logger.logImportant(NAME + "Dane sa spojne") connection._do_closing_handshake() def findActiveUpToDateServer(addresses, versions): addressesToRet = [] maxVersionAddresses = findServersWithMaxDataVersion(versions) for address in maxVersionAddresses: logger.logInfo(NAME + "analizowany adres " + address) if address in addresses: logger.logInfo(NAME + "Adres wystepuje w adresach") if addresses[address] == "T": logger.logInfo(NAME + "znalezino serwer do odpytania " + address) addressesToRet.append(address) return addressesToRet def findServersWithMaxDataVersion(versions):