def run(self):
startime = time.time()
while (time.time() - startime < self.T):
for act in self.actList:
if time.time() - startime > self.T:
return
if act[0] == "GET":
self.__result.append(
Get.Get(act[1].strip(), act[2].strip()).submit())
elif act[0] == "POST":
self.__result.append(
Post.Post(act[1].strip(), act[2].strip(),
act[3].strip()).submit())
else:
if not act[1] == "-1":
time.sleep(int(act[1]))
else:
time.sleep(R.randint(0, 5))
while True:
if Global.mutex.acquire(5):
# print self.i
Global.result.append(self.__result)
Global.mutex.release()
break
else:
time.sleep(R.randint(0, 3))
def run(self):
startime = time.time()
gt = Get.Get(self.url, self.path)
while (time.time() - startime < self.T):
self.__result.append(gt.submit())
while True:
if Global.mutex.acquire(5):
# print self.i
Global.result.append(self.__result)
Global.mutex.release()
break
else:
time.sleep(R.randint(0, 3))
def GetAnswer(self):
buffer = Utils.FileOpener()
send = Put(self.__socket, self.address, self.port)
errors = Errors(self.address, self.port)
data_rec = Structure(self.request)
file = None
blk_num = 0
connect = True
print("Filename : " + self.filename)
filename = self.filename.split('/')
if 1 == len(filename):
self.filename = filename[0]
else:
self.__send__error__(0x02, errors, "access violation")
connect = False
if self.mode == WRITE_REQUEST:
send.send_ack(0)
file = buffer.openfile(self.path + self.filename, 'wb+')
elif self.mode == READ_REQUEST:
file = buffer.openfile(self.path + self.filename, 'rb')
if file is None:
if self.mode == WRITE_REQUEST:
"""--------------------------------------------------------------------------------------------------"""
""" access violation """
"""--------------------------------------------------------------------------------------------------"""
self.__send__error__(0x02, errors, "access violation")
connect = False
if self.mode == READ_REQUEST:
"""--------------------------------------------------------------------------------------------------"""
""" file not found """
"""--------------------------------------------------------------------------------------------------"""
self.__send__error__(0x01, errors, "unable to read file : " + self.filename)
connect = False
restart = False
write_err = False
opcode = 0x04
init = False
while connect:
init = False
recv = Get(self.mode, self.__socket, self.address, self.port)
if self.mode == READ_REQUEST:
"""--------------------------------------------------------------------------------------------------"""
""" send file """
"""--------------------------------------------------------------------------------------------------"""
if not restart and opcode == ACK:
blk = buffer.readfile()
blk_num += 1
if opcode == READ_REQUEST and blk_num == 1:
"""----------------------------------------------------------------------------------------------"""
""" resend init ack """
"""----------------------------------------------------------------------------------------------"""
rand = randint(0, 100)
if rand >= self.average:
send.send_content(blk_num, blk)
init = True
data, addr = self.__socket.recvfrom(PACKET_SIZE)
self.port = addr[1]
send.port = addr[1]
opcode = struct.unpack("!h", data[0:2])[0]
if opcode == ACK and not init:
"""----------------------------------------------------------------------------------------------"""
""" send next block or lost block """
"""----------------------------------------------------------------------------------------------"""
rand = randint(0, 100)
if rand >= self.average or len(blk) < DATA_SIZE:
send.send_content(blk_num, blk)
restart = False
else:
restart = True
"""----------------------------------------------------------------------------------------------"""
""" recv ack """
"""----------------------------------------------------------------------------------------------"""
data, addr = self.__socket.recvfrom(PACKET_SIZE)
self.port = addr[1]
send.port = addr[1]
opcode = struct.unpack("!h", data[0:2])[0]
structure = data_rec.get_ack_struct(data)
if structure.block == blk_num:
"""------------------------------------------------------------------------------------------"""
""" block matching """
"""------------------------------------------------------------------------------------------"""
restart = False
elif structure.block > blk_num:
"""------------------------------------------------------------------------------------------"""
""" block not matching """
"""------------------------------------------------------------------------------------------"""
rand = randint(0, 100)
if rand >= self.average:
self.__send__error__(0x04, errors, 'invalid id : ' + structure.block)
restart = True
else:
restart = True
else:
restart = True
if len(blk) < DATA_SIZE:
timer = Timeout(5.0, self.__socket)
"""----------------------------------------------------------------------------------------------"""
""" final blk """
"""----------------------------------------------------------------------------------------------"""
while connect:
try:
max_exceed = timer.start_timer()
if -1 == max_exceed:
print("closing connection")
connect = False
else:
data, addr = self.__socket.recvfrom(PACKET_SIZE)
opcode = struct.unpack("!h", data[0:2])[0]
if opcode == ACK:
if struct.unpack('!h', data[2:4])[0] == blk_num:
connect = False
print("True " + str(blk_num) + " " + str(data[2:4]))
else:
print("False " + str(blk_num) + " " + str(data[2:4]))
connect = True
elif opcode == READ_REQUEST or opcode == WRITE_REQUEST:
return (data, addr)
else:
send.send_content(blk_num, blk)
connect = True
except socket.timeout:
connect = False
elif self.mode == WRITE_REQUEST:
"""--------------------------------------------------------------------------------------------------"""
""" recv file """
"""--------------------------------------------------------------------------------------------------"""
data, addr = self.__socket.recvfrom(PACKET_SIZE)
self.port = addr[1]
send.port = addr[1]
timer = Timeout(5.0, self.__socket)
opcode = struct.unpack("!h", data[0:2])[0]
if opcode == WRITE_REQUEST and blk_num == 0:
"""----------------------------------------------------------------------------------------------"""
""" resend ack """
"""----------------------------------------------------------------------------------------------"""
send.send_ack(0)
elif opcode == DATA:
"""----------------------------------------------------------------------------------------------"""
""" recv next data """
"""----------------------------------------------------------------------------------------------"""
structure = data_rec.get_data_struct(data)
if structure.block == blk_num + 1:
self.port = addr[1]
"""------------------------------------------------------------------------------------------"""
""" block matching """
"""------------------------------------------------------------------------------------------"""
if not restart:
write = buffer.writefile(structure.data)
if write < len(structure.data):
self.__send__error__(0x03, errors, "disk full")
connect = False
write_err = True
else:
write_err = False
blk_num += 1
rand = randint(0, 100)
if rand >= self.average or len(structure.data) < DATA_SIZE:
if not write_err:
send.port = addr[1]
send.send_ack(structure.block)
restart = False
else:
rand = randint(0, 100)
if rand >= self.average:
self.__send__error__(0x04, errors, "invalid transfer id : " + structure.block)
restart = True
else:
"""------------------------------------------------------------------------------------------"""
""" block not matching """
"""------------------------------------------------------------------------------------------"""
self.__send__error__(0x04, errors, "wrong block id for file: " + self.filename)
restart = True
else:
"""----------------------------------------------------------------------------------------------"""
""" other error """
"""----------------------------------------------------------------------------------------------"""
self.__send__error__(0x05, errors, "Operation not permitted during transfer:" + opcode)
connect = False
if len(structure.data) < DATA_SIZE and opcode == DATA:
"""----------------------------------------------------------------------------------------------"""
""" final ack """
"""----------------------------------------------------------------------------------------------"""
while connect:
try:
max_exceed = timer.start_timer()
if -1 == max_exceed:
print("closing connection")
connect = False
else:
data, addr = self.__socket.recvfrom(PACKET_SIZE)
opcode = struct.unpack("!h", data[0:2])[0]
if opcode == ACK:
if struct.unpack("!h", data[2:4])[0] == blk_num:
print("True " + str(blk_num) + " " + str(data[2:4]))
connect = False
else:
print("False " + str(blk_num) + " " + str(data[2:4]))
connect = True
elif opcode == READ_REQUEST or opcode == WRITE_REQUEST:
return data, addr
else:
send.send_ack(blk_num)
connect = True
except socket.timeout:
connect = False
else:
self.__send__error__(0x05, errors, "Operation not permitted :" + str(self.mode))
connect = False
return None, None
def GetAnswer(self, mode):
recv = Get(mode, self.__socket, self.address, self.port)
timeout = True
timer = self.timer
reply = None
connect = True
message_id = -1
buffer = Utils.FileOpener()
errors = Errors(self.address, self.port)
file = False
if mode == READ_REQUEST:
mode = 0x03
file = buffer.openfile(self.output_file, 'wb+')
if None == file:
self.__send__error__(0x02, errors, "access violation")
elif mode == WRITE_REQUEST:
mode = 0x01
message_id = 0
while timeout:
timeout = False
try:
exceed = timer.start_timer()
if exceed == -1:
self.__socket.close()
print("no ack for write request received")
return
reply = recv.get_ack()
if type(reply) is tuple:
if errors.is_critical(reply[0], reply[1]):
errors.print_error()
timer.cancel_timer()
self.__socket.close()
return
else:
errors.print_error()
timeout = True
timer.cancel_timer()
except socket.timeout:
rand = randint(0, 100)
if rand >= self.average:
self.__socket.sendto(self.request_packed,
(self.address, self.port))
timeout = True
file = buffer.openfile(self.input_file, 'rb')
if None == file:
self.__send__error__(0x01, errors, "file not found")
if None == file:
self.__socket.close()
return
restart = False
while connect:
if mode == 0x01:
""" send file """
get = Get(WRITE_REQUEST, self.__socket, self.address,
self.port)
send = Put(self.__socket, self.address, self.port)
if not restart:
data = buffer.readfile()
message_id += 1
rand = randint(0, 100)
if rand >= self.average:
send.send_content(message_id, data)
if len(data) < DATA_SIZE:
connect = False
try:
restart = False
max_exceed = timer.start_timer()
if -1 == max_exceed:
print("connection lost")
break
reply = get.get_ack()
if type(reply) is tuple:
if errors.is_critical(reply[0], reply[1]):
errors.print_error()
break
else:
restart = True
max_exceed = timer.restart_timer()
if -1 == max_exceed:
print("connection lost")
break
self.__send__error__(0x04, errors,
"id invalid " + str(reply[0]))
errors.print_error()
connect = True
else:
timer.cancel_timer()
if reply != message_id:
self.__send__error__(0x04, errors,
"invalid id" + str(reply))
errors.print_error()
connect = True
restart = True
except socket.timeout:
connect = True
restart = True
elif mode == 0x03:
""" get file """
send = Put(self.__socket, self.address, self.port)
get = Get(READ_REQUEST, self.__socket, self.address, self.port)
try:
max_exceed = timer.start_timer()
if -1 == max_exceed:
print("connection lost")
break
reply = get.get_content()
if get.error:
if errors.is_critical(reply[0], reply[1]):
errors.print_error()
break
else:
restart = True
max_exceed = timer.restart_timer()
if -1 == max_exceed:
print("connection lost")
break
else:
if len(reply[1]) < DATA_SIZE:
connect = False
timer.cancel_timer()
if buffer.writefile(reply[1]) < len(reply[1]):
self.__send__error__(0x03, errors, "disk full")
break
except socket.timeout:
restart = True
if not restart:
message_id += 1
rand = randint(0, 100)
if message_id == 0 and restart:
if rand >= self.average:
self.__socket.sendto(self.request_packed,
(self.address, self.port))
else:
if rand >= self.average:
send.send_ack(message_id)
if not connect:
final_ack = False
while not final_ack:
try:
exceed = timer.start_timer()
if exceed == -1:
break
content = recv.get_content()
rand = randint(0, 100)
if rand >= self.average:
send.send_ack(message_id)
except socket.timeout:
final_ack = True
self.__socket.close()
return
