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
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
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 )
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 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
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])
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
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 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 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
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 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()
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")
def execute(paramsDictionary, message): socket = paramsDictionary["SOCKET"] queue = paramsDictionary["QUEUE"] pingWaitResponseTime = int(paramsDictionary["CONFIG_PARAMS"]["pingWaitResponseTime"]) logger.logInfo(NAME + "Maksymalny czas oczekiwania na odpowiedz = " + str(pingWaitResponseTime)) wasError = False errorMessage = "" try: socket.send_message(PING) logger.logInfo(NAME+ "Wysylam ping") queue.get(True, int(pingWaitResponseTime)) except Queue.Empty: wasError = True errorMessage = "Serwer nie otrzymal odpowiedzi na ping" logger.logError(NAME + "serwer nie otrzymal odpowiedzi na Ping zamykanie polaczenia") except ConnectionTerminatedException, a: wasError = True logger.logError(NAME+ "Server zamknal polaczenie") errorMessage = "Serwer zamknal polaczenie"
def connect(self, host, port, resource): self._socket = socket.socket() self.dictionary['server_port'] = port self.dictionary['server_host'] = host self.dictionary['resource'] = resource self._socket.settimeout(int(self.dictionary.get('socket_timeout'))) try: logger.logInfo(NAME + "connecting to " + host + ":" + str(port) + resource ) self._socket.connect((host, int(port))) if self.dictionary.get('use_tls') == 'True': self._socket = _TLSSocket(self._socket) version = self.dictionary.get('protocol_version') self._handshake = ClientHandshakeProcessor( self._socket, self.dictionary) self._handshake.handshake() logger.logInfo(NAME + 'Nawiazano polaczenie z ' + host+":"+str(port)) request = ClientRequest(self._socket) version_map = { _PROTOCOL_VERSION_HYBI13: common.VERSION_HYBI13} request.ws_version = version_map[version] stream_option = StreamOptions() stream_option.mask_send = True stream_option.unmask_receive = False self._stream = Stream(request, stream_option) return OK_FLAG except Exception, e: logger.logError(NAME+"Wystapil problem") logger.logError(NAME + e.message) print(e.message) return ERROR_FLAG
def checkDataVersions(self): logger.logInfo(NAME + "Rozpoczynanie transakcji odczytu") self.processor.lockFile() dataVersions = self.processor.readFile() myDataVersion = dataVersions[LOCALHOST_NAME] logger.logInfo("Lokalna wersja danych = " + myDataVersion) count = 0 myVersion = 0 for key in dataVersions: count = count + 1 version = dataVersions[key] if version == myDataVersion: myVersion = myVersion + 1 logger.logInfo(NAME + "Zgodnych wersji: " + str(myVersion)) logger.logInfo(NAME + "Wszystkich wersji: " + str(count)) self.processor.unlockFile() min = int(math.floor(count / 2) + 1) if myVersion >= min: logger.logInfo(NAME + "Warunek kworum dla odczytu spelniony") return True else: logger.logError(NAME + "Nie mozna czytac") return False
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): logger.logInfo(NAME+ "Server dostal zgloszenie") 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() login = dbParamsDict["DEFAULT_LOGIN"] password = dbParamsDict["DEFAULT_PASSWORD"] clientVersion = socket.receive_message() logger.logInfo(NAME + "client version " + clientVersion) lockFilePath = paramsDictionary["HOME_PATH"]+"ServerSide/config/database_config/dbLock.dat" lock = FileLock(lockFilePath,3,.05) try: lock.acquire() except Exception, e: logger.logError(NAME + e.message) socket.send_message(LOCK_ERROR) return apache.HTTP_OK
def run(self): try: logger.logInfo(NAME+"wewnatrz watku") while( True ): logger.logInfo(NAME+"Oczekiwanie na wiadomosc") received = self.paramsDictionary["SOCKET"].receive_message() logger.logInfo(NAME+"odebrano " + received) if received != None: self.dispatch(received) else: logger.logError(NAME+"odebrano pusta wiadomosc") except Exception, e: logger.logError(NAME+"Wystapil problem z polaczeniem") logger.logError(NAME + e.message) raise Exception("Problem z polaczeniem w watku nasluchujacym")
addressesfile.unlockFile() addressesToConnect = findActiveUpToDateServer(addresses, dataVersions) try: if len(addressesToConnect) > 0: connection = Connection(homePath + "ServerSide/config/connection_config.conf" ) for addressToConnect in addressesToConnect: if connection.connect(addressToConnect, 80, RESOURCE) != ERROR: connection.send_message(dataVersions[LOCALHOST_NAME]) version = connection.get_message() if version != LOCK_ERROR: logger.logInfo(NAME + "Polaczony z " + addressToConnect) break if version == LOCK_ERROR: logger.logError(NAME + "Nie mozna zaktualizowac serwera") return configReader = ConfigurationReader(paramsDictionary["HOME_PATH"]+"ServerSide/config/database_config/database.conf") dbParamsDict = configReader.readConfigFile() 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.logInfo(NAME + "polaczenie z baza nawiazane") cursor.execute("select * from versions where id > " + str(clientVersion) + " order by id") logger.logInfo(NAME + "komenda wyslana do bazy") for version, command in cursor.fetchall(): socket.send_message(str(version)) socket.send_message(command) logger.logInfo(NAME + "Wyslano " + str(version) + " " + command) socket.send_message(END) ticket = TicketUtil.getCurrentExpectedTicket() socket.send_message(str(ticket)) logger.logInfo(NAME + "wyslano wiadomosc konczaca") return apache.HTTP_OK except MySQLdb.Error, e: logger.logError("%d %s" % (e.args[0], e.args[1])) if lock.is_locked: lock.release() return apache.HTTP_OK except Exception, ee: logger.logError(NAME + ee.message) if lock.is_locked: lock.release() return apache.HTTP_OK
queue = paramsDictionary["QUEUE"] pingWaitResponseTime = int(paramsDictionary["CONFIG_PARAMS"]["pingWaitResponseTime"]) logger.logInfo(NAME + "Maksymalny czas oczekiwania na odpowiedz = " + str(pingWaitResponseTime)) wasError = False errorMessage = "" try: socket.send_message(PING) logger.logInfo(NAME+ "Wysylam ping") queue.get(True, int(pingWaitResponseTime)) except Queue.Empty: wasError = True errorMessage = "Serwer nie otrzymal odpowiedzi na ping" logger.logError(NAME + "serwer nie otrzymal odpowiedzi na Ping zamykanie polaczenia") except ConnectionTerminatedException, a: wasError = True logger.logError(NAME+ "Server zamknal polaczenie") errorMessage = "Serwer zamknal polaczenie" except Exception, e: wasError = True logger.logError(NAME+ "error - zamykanie polaczenia") logger.logError(NAME + e.message) errorMessage = "Wystapil nieznany problem" finally: if wasError: raise Exception(errorMessage)
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 #1000100100000000 - Ping frame in binary with no data #1000101000000000 - Pong frame in binary with no data
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")