def generate_ACommu():
acommu = commu_pb2.ACommunicate()
aloaded = acommu.aloaded.add()
aloaded.packageid = 1
aloaded.truckid = 2
aloaded.seqnum = 3
return acommu
def generate_ack_response(self):
acommu = commu_pb2.ACommunicate()
for uorderplaced in self.request.uorderplaced:
acommu.acks.append(uorderplaced.seqnum)
for uarrived in self.request.uarrived:
acommu.acks.append(uarrived.seqnum)
for udelivered in self.request.udelivered:
acommu.acks.append(udelivered.seqnum)
return acommu
def generate_ALoadingFinished(self):
ac = commu_pb2.ACommunicate()
loadlist = []
for loaded in self.aresponse.loaded:
pckid = loaded.shipid
truckid = get_truckid_from_DB(pckid)
loadlist.append((truckid, pckid))
add_ALoadingFinished(loadlist, ac)
return ac
def __init__(self, addr, whid, x, y, packageid, UPSuserid):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect(addr)
self.acommunicate = commu_pb2.ACommunicate()
self.request = self.acommunicate.aorderplaced.add()
self.request.whid = whid
self.request.x = x
self.request.y = y
self.request.packageid = packageid
self.request.UPSuserid = UPSuserid
self.request.seqnum = 0
def find_AOrderPlaced(shipid):
try:
connection = psycopg2.connect(user=USER,
password=PASSWORD,
host=HOST,
port=PORT,
database=DATABASE)
cursor = connection.cursor()
# SELECT * FROM mytable WHERE "date" >= NOW() - INTERVAL '5 minutes';
#postgreSQL_select_Query = """select message from order_upsseq where time > (current_timestamp - make_interval(secs := %s))"""
#intervalInSecs = 300;
#print(postgreSQL_select_Query % intervalInSecs)
#cursor.execute(postgreSQL_select_Query, [intervalInSecs])
postgreSQL_select_Query = """select message from order_placed where packageid = %s"""
print(postgreSQL_select_Query % (shipid, ))
cursor.execute(postgreSQL_select_Query, (shipid, ))
print(
"Selecting message from order_topack table using cursor.fetchall")
records = cursor.fetchall()
print("Print each row and it's columns values")
cmd = None
for row in records:
jsonobj = row[0]
cmd = protobuf_json.json2pb(commu_pb2.ACommunicate(), jsonobj)
break
if cmd:
for aorderplaced in cmd.aorderplaced:
insert_ACommunicate_to_DB(cmd, aorderplaced.seqnum)
# insert_A_to_DB(aorderplaced.seqnum, cmd)
postgreSQL_delete_Query = """delete from order_placed where packageid = %s"""
#postgreSQL_delete_Query = 'delete from order_truck where "truckId" = ' + truckid
cursor.execute(postgreSQL_delete_Query, (shipid, ))
connection.commit()
except (Exception, psycopg2.Error) as error:
print("Error while fetching data from PostgreSQL", error)
finally:
#closing database connection.
if (connection):
cursor.close()
connection.close()
print("PostgreSQL connection is closed")
return cmd
def getAOrderPlaced(self, seqnum):
acommu = commu_pb2.ACommunicate()
pckid = None
for aorderplaced in self.request.aorderplaced:
pckid = aorderplaced.packageid
for product in aorderplaced.things:
productid = product.name
try:
product.name = get_name_from_DB(productid)
except:
product.name = "Unknown"
aorderplaced.seqnum = aorderplaced.packageid * 10 + 1
acommu = self.request
insert_AOrderPlaced_to_DB(pckid, acommu)
def select_timeout_from_ACommunicate():
try:
connection = psycopg2.connect(user=USER,
password=PASSWORD,
host=HOST,
port=PORT,
database=DATABASE)
cursor = connection.cursor()
# SELECT * FROM mytable WHERE "date" >= NOW() - INTERVAL '5 minutes';
#postgreSQL_select_Query = """select message from order_upsseq where time > (current_timestamp - make_interval(secs := %s))"""
#intervalInSecs = 300;
#print(postgreSQL_select_Query % intervalInSecs)
#cursor.execute(postgreSQL_select_Query, [intervalInSecs])
postgreSQL_select_Query = """select message from order_upsseq where time < %s - INTERVAL '30 second'"""
print(postgreSQL_select_Query)
dt = datetime.datetime.now()
cursor.execute(postgreSQL_select_Query, [dt])
print("Selecting message from wareHouse table using cursor.fetchall")
records = cursor.fetchall()
print("Print each row and it's columns values")
cmdlist = []
for row in records:
jsonobj = row[0]
cmd = protobuf_json.json2pb(commu_pb2.ACommunicate(), jsonobj)
cmdlist.append(cmd)
postgreSQL_update_Query = """update order_upsseq set time = %s where time < %s - INTERVAL '30 second'"""
#postgreSQL_delete_Query = 'delete from order_truck where "truckId" = ' + truckid
cursor.execute(postgreSQL_update_Query,
(datetime.datetime.now(), datetime.datetime.now()))
connection.commit()
except (Exception, psycopg2.Error) as error:
print("Error while fetching data from PostgreSQL", error)
finally:
#closing database connection.
if (connection):
cursor.close()
connection.close()
print("PostgreSQL connection is closed")
return cmdlist
def listen_for_web(proxysocket, worldsocket, UPSsocket):
while True:
proxysocket.listen(4)
# print "Multithreaded Python server : Waiting for connections from TCP clients..."
(websocket, (ip, port)) = proxysocket.accept()
print("connected")
# recv request from front end
message = recv_response(websocket)
request = commu_pb2.ACommunicate()
request.ParseFromString(message)
print("----------------------------------")
print("Web content")
print(request)
print("----------------------------------")
# create a thread and handle
handler = threading.Thread(target=handle_web_request,
args=(request, worldsocket, UPSsocket))
handler.start()
def __init__(self, request):
self.request = request
self.ac = amazon_pb2.ACommands() # generate a protocol buff
self.uc = commu_pb2.ACommunicate() # generate
self.deal_with_description()
tcpServer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcpServer.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpServer.bind(('', TCP_PORT))
threads = []
while True:
tcpServer.listen(4)
# print "Multithreaded Python server : Waiting for connections from TCP clients..."
(conn, (ip,port)) = tcpServer.accept()
print("connected")
# recv request from front end
message = recv_response(conn)
request = commu_pb2.ACommunicate()
request.ParseFromString(message)
print(request)
wp = WebRequestParser(request)
wp.getAPurchaseMore(0)
wp.getAPack(1)
wp.getAOrderPlaced(2)
print("ACommands")
print(wp.getACommands())
print("UCommunicates")
print(wp.getUCommunicate())
# newthread = ClientThread(ip,port)
# newthread.start()
# threads.append(newthread)
