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()