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 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 )
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")
versionsFile.unlockFile() if checkIfServerIsUpToDate(dataVersions) == True: logger.logInfo(NAME + "Dane na serwerze sa aktualne") lock.release() return addressesfile = FileProcessor(paramsDictionary["HOME_PATH"]+"ServerSide/config/addresses.conf") addressesfile.lockFile() addresses = addressesfile.readFile() 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
def getTicket():
connection = Connection("/home/dur/Projects/ServerSide/config/connection_config.conf")
params = readTempVars()
connection.connect(params[TICKET_PARAM], 80, "/ticket")
return connection.get_message()
