def get_posts(self,
request: PostQuery,
context: grpc.RpcContext = None) -> Iterator[Post]:
postgres_pool_conn = self.postgres_pool.getconn()
if postgres_pool_conn:
request_username = request.username
request_start = request.starting_id
request_limit = request.limit
ps_cursor = postgres_pool_conn.cursor()
# Ensure username cosists only of alphanumeric characters.
validate = re.compile("[A-Za-z0-9]+$")
valid_user = validate.match(request_username)
if not valid_user:
context.set_code(grpc.StatusCode.INTERNAL)
context.set_details('Invalid Username')
yield Post()
return
# Retrieve password for the provided username from user_setting
ps_cursor.execute(
"""SELECT post_id, post_date, msg, lat, long FROM posts \
WHERE username = '******' ORDER BY post_date DESC LIMIT {1} OFFSET {2};"""
.format(request_username, request_limit, request_start))
ps_cursor.close()
rows = ps_cursor.fetchall()
self.postgres_pool.putconn(postgres_pool_conn)
for row in rows:
yield Post(datetime=int(row[0]),
msg=row[1],
username=request.username,
loc=Location(lat=row[2], long=row[3]))
def test_create_post_empty_msg(self):
with grpc.insecure_channel(target=self.post_importer_host +
":9000") as channel:
s = PostImporterServiceStub(channel=channel)
post = Post(username="******", datetime=int(time.time() * 1000))
try:
s.create_post(post)
assert False, "Accepted invalid post"
except:
assert True
def test_create_post_empty(self):
with grpc.insecure_channel(target=self.post_importer_host +
":9000") as channel:
s = PostImporterServiceStub(channel=channel)
post = Post()
try:
s.create_post(post)
assert False, "Accepted invalid post"
except:
assert True
def submit_posts(api: ApiLayerServiceStub, sentence: str):
f = post(post=Post(username=token.username, msg=sentence), api=api)
try:
f.result(5)
except grpc.FutureTimeoutError:
print("Message timed out")
except Exception as e:
print("Unknown error occured:", e)
return 1
def test_post(self):
with grpc.insecure_channel(target=self.apilayer_host +
":50051") as channel:
s = ApiLayerServiceStub(channel=channel)
p = Post(username="******",
msg="hello world",
loc=Location(lat=48.464051, long=-123.310215))
try:
s.post(p)
assert True
except:
assert (False, "failed to post")
def fetch(self,
request: WallQuery,
context: grpc.RpcContext = None) -> Iterator[Post]:
request_user = request.username
request_limit = request.limit
request_start = 0 if request.starting_id < 0 else request.starting_id
# Ensure username consists only of alphanumeric characters.
validate = re.compile("[A-Za-z0-9]+$")
valid_user = validate.match(request_user)
if not valid_user:
context.set_code(grpc.StatusCode.INTERNAL)
context.set_details('Invalid Username')
logging.info("Invalid username")
yield from []
return
postgres_pool_conn = self.postgres_pool.getconn()
if postgres_pool_conn:
ps_cursor = postgres_pool_conn.cursor()
limit_statement = "LIMIT {0}".format(
request_limit) if request_limit > 0 else ""
query = """SELECT post_id
FROM wall
WHERE username = '******' AND post_id >= {1}
ORDER BY datetime DESC {2};""" \
.format(request_user, request_start, limit_statement)
print(query)
ps_cursor.execute(query)
posts = ps_cursor.fetchall()
print("Got rows: ", len(posts))
for post in posts:
try:
post_filled = self.posts_stub.fetch(
Post(id=post[0], username=request_user))
yield post_filled
except Exception as e:
logging.error("Failed to fetch post: ", e)
ps_cursor.close()
self.postgres_pool.putconn(postgres_pool_conn)
else:
logging.error("Failed to get postgres connection")
yield from []
return
def test_create_post_invalid_loc(self):
with grpc.insecure_channel(target=self.post_importer_host +
":9000") as channel:
s = PostImporterServiceStub(channel=channel)
post = Post(username="******",
datetime=int(time.time() * 1000),
msg="here is my msg",
id=-1,
loc=Location(lat=-100, long=-200))
try:
s.create_post(post)
assert False, "Accepted invalid post"
except:
assert True
def test_create_post_invalid_id(self):
with grpc.insecure_channel(target=self.post_importer_host +
":9000") as channel:
s = PostImporterServiceStub(channel=channel)
post = Post(username="******",
datetime=int(time.time() * 1000),
msg="here is my msg",
id=-1)
try:
# Shouldn't throw an exception, should replace id
s.create_post(post)
assert True
except:
assert False
def fetch(self, request: Post, context: grpc.RpcContext = None) -> Post:
request_username = request.username
# Ensure username cosists only of alphanumeric characters.
validate = re.compile("[A-Za-z0-9]+$")
valid_user = validate.match(request_username)
if not valid_user:
context.set_code(grpc.StatusCode.INTERNAL)
context.set_details('Invalid Username')
return request
postgres_pool_conn = self.postgres_pool.getconn()
if postgres_pool_conn:
post_id = request.id
ps_cursor = postgres_pool_conn.cursor()
# We are doing a query based on primary key, so it should be O(logn)
ps_cursor.execute(
"""SELECT extract(epoch from post_date at time zone 'utc'), msg, lat, long FROM posts \
WHERE post_id = {0} LIMIT 1;""".format(
post_id))
row = ps_cursor.fetchone()
ps_cursor.close()
print("Got Row: ", row)
self.postgres_pool.putconn(postgres_pool_conn)
if row is not None:
# Fill in the post with the additional data
resp = Post(datetime=int(row[0]),
msg=row[1],
username=request.username,
loc=Location(lat=row[2], long=row[3]))
return resp
return request
elif prompt == "news_feed":
# Get the news feed
print_news_feed(username=token.username, api=api)
elif prompt == "postrand":
if token.username in [None, ""]:
logging.error("Must login first")
else:
num_posts = input("#: ")
if num_posts == "inf":
num_submitted = 0
start_time = time()
while True:
try:
p = Post(msg=gen.sentence(),
username=token.username)
post(p, api).result()
num_submitted += 1
except KeyboardInterrupt:
break
end_time = time()
print_time_report(time=end_time - start_time,
num=num_submitted)
else:
num_posts = int(num_posts)
num_threads = int(input("# threads: "))
pool = Pool(processes=num_threads)
pieces = []
gen.init_sentence_cache()