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 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 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 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 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 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")
def __init__(self, configFile): self.configFile = configFile configReader = ConfigurationReader(self.configFile) self.dictionary=configReader.readConfigFile() self._socket = None self.list=[]
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"])
