def sleep_thread():
global balance
global branches_all
global branch_soc_list
global port
t = float(sys.argv[3])
while 1:
print "Sleeping for", t / 1000, "seconds"
sleep(t / 1000)
print "Woke up"
transfer_msg = bank_pb2.Transfer()
withdraw = randint(10, 50)
val = random.choice(branch_soc_list.keys())
if withdraw <= balance:
transfer_msg.money = withdraw
transfer_msg.src_branch = sys.argv[2]
transfer_msg.dst_branch = str(val)
send_message = bank_pb2.BranchMessage()
send_message.transfer.CopyFrom(transfer_msg)
lock = threading.Lock()
lock.acquire()
if not RECORD[int(val)]:
print "Sending", withdraw, "to", val
balance -= withdraw
branch_soc_list[val].sendall(send_message.SerializeToString())
print "Remaining balance is:", balance
else:
print "Not sending to", val
lock.release()
def MoneyTransfer(self):
global TOTAL_BALANCE
global branchName
global branhList
global moneyTransfer
global timeLimit
while True:
logger.debug("Money Transfer.............")
logger.debug("Money Transfer Status = "+str(moneyTransfer) +" Current Branch Balance = "+ str(TOTAL_BALANCE))
if moneyTransfer == True and TOTAL_BALANCE>50:
randomBranch = random.choice(branhList)
print randomBranch.ip
print randomBranch.port
MoneyTransferMsg = bank_pb2.Transfer()
MoneyTransferMsg.money = (int) ((TOTAL_BALANCE* random.randint(1,5)) /100)
MoneyTransferMsg.src_branch = branchName
with self.critical_section_lock:
if moneyTransfer == True :
TOTAL_BALANCE = TOTAL_BALANCE - MoneyTransferMsg.money
branchsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
branchsocket.connect((randomBranch.ip, randomBranch.port))
branchMessage = bank_pb2.BranchMessage()
branchMessage.transfer.CopyFrom(MoneyTransferMsg)
branchsocket.sendall(pickle.dumps(branchMessage))
branchsocket.close()
print "Time limit +++++++ " + str(timeLimit)
time.sleep(random.uniform(0, 5))
def sendTransactions():
global BRANCH_NAME
global BRANCH_BALANCE
global BRANCH_LIST
global isUpdate
while doTransfer:
random_entry = random.choice(BRANCH_LIST)
if BRANCH_BALANCE > 50:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((random_entry["ip"], random_entry["port"]))
transfer = bank_pb2.Transfer()
transfer.money = (BRANCH_BALANCE * random.randrange(1, 5)) / 100
msg = bank_pb2.BranchMessage()
msg.transfer.CopyFrom(transfer)
BRANCH_BALANCE = BRANCH_BALANCE - transfer.money
s.sendall(pickle.dumps(msg))
s.close()
if MARKER_MSG > 1 or isCapturing:
isUpdate = True
print "TRANSFERRING %s to %s...Remainging Balance: %s\n" % (str(
transfer.money), str(
random_entry["name"]), str(BRANCH_BALANCE))
time.sleep(random.randrange(1, 5))
def run(self):
while len(self.branch_worker.branch_names) == 0:
sleep(1)
while 1:
sleep(random.randint(0, 5))
branch_number = random.randint(
0,
len(self.branch_worker.branch_names) - 1)
percent_amount = int(
random.randint(1, 5) * self.branch_worker.balance / 100)
if self.branch_worker.balance - percent_amount >= 0 and socket.gethostbyname(
socket.gethostname(
)) != self.branch_worker.branch_ip[branch_number]:
self.branch_worker.mutex.acquire()
self.branch_worker.balance -= percent_amount
self.branch_worker.mutex.release()
transfer_message = bank_pb2.Transfer()
transfer_message.money = percent_amount
self.branch_worker.client_branch_Message.transfer.money = transfer_message.money
self.branch_worker.sock_dict.get(
self.branch_worker.branch_names[branch_number]).send(
self.branch_worker.client_branch_Message.
SerializeToString())
def thread_sender(handler):
addresses = []
# Find addresses of all branches excpet itself
while True:
if handler.start_connecting:
for i in range(0, handler.b_counter):
if handler.b_names[i] != handler.name:
address = (handler.b_ips[i], handler.b_ports[i])
addresses.append(address)
break
# Send message to periodically to every branch
while True:
if handler.markers_going:
continue
# print handler.name + ' has ' + str(handler.balance)
amount = int(math.floor(randint(1, 5) * handler.balance / 100))
# amount = 5
if handler.balance - amount < 0:
print handler.name + ' --> balance cannot be negative, will try again'
continue
dest = randint(0, handler.b_counter - 2)
delay = randint(0,5)
# delay = 0.05
try:
# print ' ' + handler.name + ' sends ' + str(amount) + ' to ' + str(addresses[dest])
t = bank_pb2.Transfer()
t.money = amount
t.branch_name = handler.name
msg = bank_pb2.BranchMessage()
msg.transfer.CopyFrom(t)
balance_lock.acquire()
if not handler.markers_going:
handler.balance = handler.balance - amount
balance_lock.release()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(addresses[dest])
if not handler.markers_going:
sock.sendall(msg.SerializeToString())
except:
print handler.name + ' could not send the message'
time.sleep(delay)
sock.close()
def transfer(branch):
#print('Transfer message at port %i' % branch.port)
branchName = branch.name
interval = branch.interval
minPercent = 1
maxPercent = 5
numBranches = len(branch.branches)
if numBranches > 0:
# select receiveBranch
port = sorted(branch.branches.keys())[random.randint(
0, numBranches - 1)]
receiveBranch = branch.branches[port]
# decrease balance
percent = random.randint(minPercent, maxPercent) / 100.0
amount = int(branch.balance * percent)
branch.updateBalance(False, amount)
#output
if branch.outputFlag:
oldName = branchName
newName = receiveBranch.name
balance = branch.balance
print('[**] Transfer %s -> %s (%i) Balance = %i [SENDING]' %
(oldName, newName, amount, balance))
# create transfer message
transfer = bank_pb2.Transfer()
transfer.send_branch = branchName
transfer.amount = amount
# attach transfer message to BranchMessage
bm = bank_pb2.BranchMessage()
bm.transfer.CopyFrom(transfer)
# send transfer message
branch.sendMessage(bm, port)
# add update communication channel
branch.updateCommChannel(receiveBranch.name, amount)
else:
print('[*] No branches to send messages')
sys.exit(0)
return
def send_money(self):
# print "The number of connections are" + str(len(self.connections))
while True:
random_connect = random.choice(self.connections)
rand_percent = random.uniform(0.01, 0.05)
self.lock.acquire()
rand_amount = self.initial_balance * rand_percent
if not rand_amount > self.curr_balance:
self.curr_balance -= int(rand_amount)
transfer_message = bank_pb2.Transfer()
transfer_message.money = int(rand_amount)
print "Sending amount " + str(transfer_message.money)
transfer_message.branch_name = self.branch_name
transfer_br_msg = bank_pb2.BranchMessage()
transfer_br_msg.transfer.CopyFrom(transfer_message)
random_connect.sendall(transfer_br_msg.SerializeToString())
self.lock.release()
sleep(random.randint(1, 5))
def send_money(self):
while True:
time_to_sleep = random.uniform(0, 5)
print('Sleeping for: {}'.format(time_to_sleep))
time.sleep(time_to_sleep)
socket_index = random.randint(0, len(self.sockets) - 1)
self.balance_mutex.acquire()
amount = int((random.uniform(0.01, 0.05) * self.balance))
self.balance = self.balance - amount
assert self.balance >= 0
print('Sending: {}'.format(amount))
print('Remaining: {}'.format(self.balance))
transfer = bank_pb2.Transfer()
transfer.money = amount
transfer.branch_name = self.name
message = bank_pb2.BranchMessage()
message.transfer.MergeFrom(transfer)
self.sockets[socket_index][1].acquire()
self.message_socket(self.sockets[socket_index][0], message)
self.sockets[socket_index][1].release()
self.balance_mutex.release()
