def world_response_handler(serialized_msg, world_comm_data, ups_comm_data):
world_response_pb = wapb2.AResponses()
world_response_pb.ParseFromString(serialized_msg)
print("world response:-------", world_response_pb)
print("----------------------------")
if world_response_pb.error:
for x in world_response_pb.error:
print(x.err, world_comm_data._all_messages[x.originseqnum])
raise AssertionError("world returned error")
for a_seqnum in world_response_pb.acks:
world_comm_data.handle_acked_message(a_seqnum)
seen_seqnums = world_comm_data.all_seen_seqnums
should_ack = set()
for purchase_pb in filter_world_unseen(seen_seqnums,
world_response_pb.arrived):
for mul_prod in purchase_pb.things:
db_interface.increment_inventory(purchase_pb.whnum, mul_prod.id,
mul_prod.count)
world_comm_data.register_incoming_seqnum(purchase_pb.seqnum)
pickup_requests = {}
for wh_id in db_interface.get_whids():
seqnum = get_seqnum()
pickup_req_pb = uapb2.AtoUPickupRequest()
pickup_req_pb.seqNum = seqnum
pickup_req_pb.warehouseId = wh_id
pickup_requests[wh_id] = pickup_req_pb
for packed_pb in filter_world_unseen(seen_seqnums,
world_response_pb.ready):
#db_lock.acquire() locking unecessary
shipid = packed_pb.shipid
shipinfo = uapb2.ShipInfo()
wh_id, ups_acc, dest_x, \
dest_y, prod_name, prod_num = db_interface.get_ship_info(shipid)
shipinfo.shipId = shipid
shipinfo.destination_x = dest_x
shipinfo.destination_y = dest_y
if ups_acc:
shipinfo.UPSaccount = ups_acc
product = uapb2.Product()
product.description = prod_name
product.count = prod_num
shipinfo.products.append(product)
pickup_requests[wh_id].shipment.append(shipinfo)
#TODO: change this to accomodate ack in the future- here i assume requests are noted
db_interface.adjust_order_status(packed_pb.shipid, "to pack",
"request_pickup")
world_comm_data.register_incoming_seqnum(packed_pb.seqnum)
for wh_id in pickup_requests:
req = pickup_requests[wh_id]
if req.shipment:
ups_comm_data.track_new_message(req.seqNum, 'AtoUPickupRequest',
req)
for loaded_pb in filter_world_unseen(seen_seqnums,
world_response_pb.loaded):
db_interface.adjust_order_status(loaded_pb.shipid, "load", "loaded")
shipid = loaded_pb.shipid
ups_comm_data.track_loaded_package(shipid)
world_comm_data.register_incoming_seqnum(loaded_pb.seqnum)
def recvFromWorld_th(socket_world, conn):
cursor = conn.cursor()
timeout = 1
while True:
world_response = world_amazon_pb2.AResponses()
#msg = tools.recv_msg_timeout(socket_world,timeout)
msg = tools.recv_msg(socket_world)
if msg == "":
continue
world_response.ParseFromString(msg)
print("+++++Recv from World: \n" + str(world_response))
# handle acks
with tools.toworld_lock:
for ack in world_response.acks:
keys = list(tools.toWorld)
for key in keys:
if ack == key and key in tools.toWorld:
tools.toWorld.pop(key)
# handle AErr
if len(world_response.error) > 0:
print("From World: recv error！")
for each in world_response.error:
print("Error: " + each.err)
print("Error originseqnum = " + str(each.originseqnum))
print("Error seqnum = " + str(each.seqnum))
tools.ack_to_world(socket_world, each.seqnum)
# recv APurchaseMore(arrived)
if len(world_response.arrived) > 0:
print("From World: recv APurchaseMore！")
for arrive in world_response.arrived:
# ack to world
tools.ack_to_world(socket_world, arrive.seqnum)
# acquire this item's count now in the warehouse(database)
sql = '''SELECT count FROM amazon_web_product WHERE item_id = %s;'''
cursor.execute(sql, (arrive.things[0].id, ))
curr_count = cursor.fetchone()
# the item's count after the replenish
remaining_items = arrive.things[0].count + curr_count[0]
sql = '''SELECT * FROM amazon_web_order WHERE is_enough = TRUE AND is_packed = FALSE AND is_order_placed = FALSE AND item_id = %s;'''
cursor.execute(sql, (arrive.things[0].id, ))
orders = cursor.fetchall()
for order in orders:
# when remaining size>=0, update the order's is_packed and is_order_placed to true
if remaining_items >= order[9]:
remaining_items -= order[9]
# update database (is_packed,is_order_placed,status), generate APack
sql = '''UPDATE amazon_web_order SET is_packed = TRUE, status = 'packing' WHERE pkgid = %s;'''
cursor.execute(sql, (order[0], ))
conn.commit()
with tools.seq_lock:
APack = tools.generate_pack(order)
tools.add_toWorld(APack)
# update database, generate ASendTruck
sql = '''UPDATE amazon_web_order SET is_order_placed = TRUE WHERE pkgid = %s;'''
cursor.execute(sql, (order[0], ))
conn.commit()
with tools.seq_lock:
ASendtruck = tools.generate_asendtruck(order)
tools.add_toUPS(ASendtruck)
else:
continue
#update count in warehouse (it should still be 0)
sql = '''UPDATE amazon_web_product SET count = %s WHERE item_id = %s;'''
cursor.execute(sql, (remaining_items, arrive.things[0].id))
conn.commit()
#recv Apacked(topack)
if len(world_response.ready) > 0:
print("From World: recv APacked！")
for pack in world_response.ready:
#ack to world
tools.ack_to_world(socket_world, pack.seqnum)
#change status to packed (this is useful to the next step)
with order_lock_db:
sql = '''UPDATE amazon_web_order SET status = 'packed' WHERE pkgid = %s;'''
cursor.execute(sql, (pack.shipid, ))
conn.commit()
sql = '''SELECT * FROM amazon_web_order WHERE pkgid = %s;'''
cursor.execute(sql, (pack.shipid, ))
order = cursor.fetchone()
if order[1]: # truckid
if order[13] == True: #is_truck_arrived
# update database
# TODO
sql = '''UPDATE amazon_web_order SET is_loaded = TRUE, status = 'loading' WHERE pkgid = %s;'''
cursor.execute(sql, (order[0], ))
conn.commit()
with tools.seq_lock:
APutOnTruck = tools.generate_load(order)
tools.add_toWorld(APutOnTruck)
#recv ALoaded(loaded)
if len(world_response.loaded) > 0:
print("From World: recv ALoaded！")
for load in world_response.loaded:
#ack to world
tools.ack_to_world(socket_world, load.seqnum)
#change status to loaded
sql = '''UPDATE amazon_web_order SET status = 'loaded' WHERE is_loaded = TRUE AND pkgid = %s;'''
cursor.execute(sql, (load.shipid, ))
conn.commit()
#generate AFinishLoading
sql = '''SELECT * FROM amazon_web_order WHERE pkgid = %s;'''
cursor.execute(sql, (load.shipid, ))
order = cursor.fetchone()
with tools.seq_lock:
AFinishLoading = tools.generate_afinishloading(order)
tools.add_toUPS(AFinishLoading)
sql = '''UPDATE amazon_web_order SET status = 'delivering', is_delivered = TRUE WHERE status = 'loaded' AND pkgid = %s;'''
cursor.execute(sql, (load.shipid, ))
conn.commit()
#recv APackage(packagestatus)
if len(world_response.packagestatus) > 0:
print("From World: recv APackage")
for packagestatus in world_response.packagestatus:
#ack to world
tools.ack_to_world(socket_world, packagestatus.seqnum)
#change status to loaded
sql = '''UPDATE amazon_web_order SET status = %s WHERE pkgid = %s;'''
cursor.execute(sql,
(packagestatus.status, packagestatus.packageid))
conn.commit()
def recv_world(socket):
response = world_amazon_pb2.AResponses()
response.ParseFromString(my_recv(socket))
return response
def responseFromWorld(sock):
message = readClientRequest(sock)
world_response = wa.AResponses()
world_response.ParseFromString(message)
return world_response
def receive_world(sock):
data = recv(sock)
msg = wapb2.AResponses()
msg.ParseFromString(data)
return msg