def web_socket_transfer_data(request): while True: line = request.ws_stream.receive_message() logger.logInfo(NAME + "Serwer otrzymal " + line) request.ws_stream.send_message(line) if line == _GOODBYE_MESSAGE: return apache.HTTP_OK
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"]
paramsDictionary["CLIENT_ADDRESS"] = request.connection.remote_ip
stopQueue = Queue()
listenThread = KillableListenThread(request.ws_stream, stopQueue)
ticket = request.ws_stream.receive_message()
currentTicket = TicketUtil.readTempVars()[EXPECTED_TICKET]
timeOut = (int(ticket) - int(currentTicket)) * 5
start = time.time()
while currentTicket < ticket and time.time() - start < timeOut:
time.sleep(1)
currentTicket = TicketUtil.readTempVars()[EXPECTED_TICKET]
if currentTicket == ticket:
request.ws_stream.send_message(OK)
listenThread.start()
if listenThread.getMessage(5) != OK:
skip(paramsDictionary, ticket)
else:
request.ws_stream.send_message(ABORT)
skip(paramsDictionary, ticket)
stopQueue.put("STOP")
return apache.HTTP_OK
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["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 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 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): global timer if timer == 0: timer = int(paramsDictionary["CONFIG_PARAMS"]["passExchangePeriod"]) logger.logInfo(NAME + "Wysylam zapytanie o stare haslo do " + paramsDictionary["CLIENT_ADDRESS"]) paramsDictionary["SOCKET"].send_message(RES_MODULE+NEW_PASS) else: timer = timer -1
def checkIfServerIsUpToDate(dataVersions): myVersion = dataVersions[LOCALHOST_NAME] for address in dataVersions: logger.logInfo(NAME + "analizuje " + address) if int(dataVersions[address]) > int(myVersion): logger.logInfo(NAME + "Dane na serwerze nie sa aktualne") return False return True
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 execute(paramsDictionary, message):
logger.logInfo(NAME + "Resetuje stan serwera")
file = FileProcessor(paramsDictionary["HOME_PATH"] + "ServerSide/config/addresses.conf")
file.lockFile()
addresses = file.readFile()
for key in addresses:
addresses[key] = "F"
file.writeToFile(addresses)
file.unlockFile()
def run(self):
self.listener.start()
while self.stopQueue.empty():
try:
message = self.internalQueue.get(True, 2)
except Empty:
logger.logInfo(NAME + "No message")
continue
self.messageQueue.put(message)
def execute(paramsDictionary, message):
logger.logInfo(NAME + "otrzymalem " + message)
splited = message.split('%')
toCall = splited[0]
if len(splited) > 1:
argument = splited[1]
else:
argument = None
function = functions[toCall]
function(paramsDictionary, argument)
def dispatch(self, message):
splited = message.split(':')
module = splited[0]
if len(splited) > 1:
message = splited[1]
else:
message = None
if( self.modules[module] != None ):
logger.logInfo(NAME+"znaleziono modul odpowiadajacy za obsluge")
for singleModule in self.modules[module]:
singleModule.execute(self.paramsDictionary, message)
def web_socket_transfer_data(request): logger.logInfo(NAME + "Zgloszenie po bilet od " + str(request.connection.remote_ip)) homePath = request.get_options()["PROJECT_LOCATION"] processor = FileProcessor(homePath + "ServerSide/config/database_config/ticketNumber.dat") processor.lockFile() number = processor.readFirstLine() nextNumber = int(number) + 1 processor.writeSingleLine(str(nextNumber)) processor.unlockFile() request.ws_stream.send_message(str(nextNumber)) logger.logInfo(NAME + request.connection.remote_ip + " otrzymal bilet " + str(nextNumber)) return apache.HTTP_OK
def getOldPassword(paramsDictionary, argument): socket = paramsDictionary["SOCKET"] remoteAddress = paramsDictionary["CLIENT_ADDRESS"] homePath = paramsDictionary["HOME_PATH"] logger.logInfo(NAME + "wyszukuje stare haslo") processor = FileProcessor(homePath+"ServerSide/config/pass/me_to_all.pass") passwords = processor.readFile() oldPass = passwords[remoteAddress] socket.send_message(RES_MODULE+OLD+"%"+oldPass) logger.logInfo(NAME + "wyslalem stare haslo do " + remoteAddress) global expectedMessage expectedMessage = NEW
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 = {}
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()
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")
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 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 acknowlage(paramsDictionary, argument): remoteAddress = paramsDictionary["CLIENT_ADDRESS"] homePath = paramsDictionary["HOME_PATH"] logger.logInfo(NAME + "dostalem potwierdzenie zmiany hasla od " + remoteAddress) file = FileProcessor(homePath+"ServerSide/config/pass/all_to_me.pass") file.lockFile() passwords = file.readFile() passwords[remoteAddress] = generatedPass file.writeToFile(passwords) file.unlockFile() logger.logInfo(NAME + "Haslo zostalo zmienione") global expectedMessage expectedMessage = OLD global generatedPass generatedPass = None
def checkActiveServersCount(self): self.addressesProcessor.lockFile() addresses = self.addressesProcessor.readFile() self.addressesProcessor.unlockFile() all = 1 available = 1 for key in addresses: all = all + 1 if addresses[key] == 'T': available = available + 1 min = int(math.floor(all / 2) + 1) if available >= min: logger.logInfo(NAME + "Warunek kworum dla odczytu spelniony, mozna wykonac operacje") return True else: logger.logInfo(NAME + "Warunek kworum dla odczytu nie jest spelniony, nie mozna wykonac operacji") return False
def web_socket_transfer_data(request): logger.logInfo(NAME + "Server dostal zgloszenie") clientAddress = request.connection.remote_ip socket = request.ws_stream homePath = request.get_options()["PROJECT_LOCATION"] try: versionsFile = FileProcessor(homePath+"ServerSide/config/database_config/data_version.dat") versionsFile.lockFile() dataVersions = versionsFile.readFile() version = socket.receive_message() logger.logInfo(NAME + "Otrzymano nowa wersje klienta " + version) dataVersions[clientAddress] = version versionsFile.writeToFile(dataVersions) versionsFile.unlockFile() except Exception, e: logger.logEerror(NAME + e.message) versionsFile.unlockFile() return apache.HTTP_OK
def prepare(self): logger.logInfo(NAME + "PrepareMethod") command = self.inputQueue.get(True, None) logger.logInfo(NAME + "Otrzymalem zapytanie sql do wykonania " + command) self.connection.send_message(PREPARE) self.connection.send_message(command) answer = self.connection.get_message() self.outputQueue.put(answer) logger.logInfo(NAME + "Zdalny serwer odpowiedzial: " + answer) if self.outputQueue.full(): self.eventVariable.set() logger.logInfo(NAME + "Wybudzanie watku transakcji")
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): 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 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 checkOldPassword(paramsDictionary, oldPass): socket = paramsDictionary["SOCKET"] remoteAddress = paramsDictionary["CLIENT_ADDRESS"] homePath = paramsDictionary["HOME_PATH"] logger.logInfo(NAME + "Otrzymalem stare haslo od " + remoteAddress) processor = FileProcessor(homePath+"ServerSide/config/pass/all_to_me.pass") passwords = processor.readFile() logger.logInfo(NAME + "spodziewane haslo " + passwords[remoteAddress] + " otrzymano " + oldPass ) if(passwords[remoteAddress] == oldPass ): logger.logInfo(NAME + "Haslo zgodne") global generatedPass generatedPass = generatePassword(PASSWORD_LENGTH) socket.send_message(RES_MODULE+NEW+"%"+generatedPass) logger.logInfo(NAME + "Wyslalem nowe haslo") global expectedMessage expectedMessage = ACK
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 setNextExpectedTicket(currentTicket):
logger.logInfo(NAME + "Otrzymalem aktualny bilet " + str(currentTicket))
tempProcessor = FileProcessor("/home/dur/Projects/ServerSide/config/tempParams.conf")
tempProcessor.lockFile()
params = tempProcessor.readFile()
if params[SKIP_TICKETS] != '':
skipped = params[SKIP_TICKETS].split(",")
else:
skipped = None
newTicket = int(currentTicket) + 1
skipped = removeAllSkippedLowerThen(skipped, newTicket)
while skipped.__contains__(str(newTicket)):
skipped.remove(str(newTicket))
newTicket = int(newTicket) + 1
toRet = ""
for single in skipped:
toRet= toRet + str(single) + ","
toRet = toRet[:-1]
params[EXPECTED_TICKET] = str(newTicket)
params[SKIP_TICKETS] = toRet
tempProcessor.writeToFile(params)
tempProcessor.unlockFile()
logger.logInfo(NAME + "Zwracam kolejny oczekiwany bilet: " + str(newTicket))
return newTicket
