Add squeak store class (#201)

* Add squeak store class

* Use squeak store class to save squeaks made from make method

* Use squeak store class to get public squeak for server get

* Use squeak store class for other squeak node methods

itests/tests/test_squeak_node.py

@@ -272,18 +272,19 @@ def test_make_reply_squeak(
     assert len(get_ancestors_response.squeak_display_entries) == 3
 
 
-def test_rate_limit(server_stub, admin_stub, signing_profile_id):
+def test_post_squeak_rate_limit(server_stub, admin_stub, whitelisted_signing_key):
     # Make 10 squeak
     for i in range(10):
         try:
-            make_extra_squeak_response = admin_stub.MakeSqueak(
-                squeak_admin_pb2.MakeSqueakRequest(
-                    profile_id=signing_profile_id, content="Hello number: {}".format(i),
-                )
+            block_height, block_hash = get_latest_block_info(lightning_client)
+            squeak = make_squeak(
+                nonwhitelisted_signing_key, "hello from itest!", block_hash, block_height
             )
+            squeak_msg = build_squeak_msg(squeak)
+            server_stub.PostSqueak(squeak_server_pb2.PostSqueakRequest(squeak=squeak_msg))
         except Exception as e:
-            make_extra_squeak_exception = e
-    assert make_extra_squeak_exception is not None
+            post_squeak_exception = e
+    assert post_squeak_exception is not None
 
 
 def test_make_signing_profile(server_stub, admin_stub):

squeakserver/node/squeak_node.py

@@ -11,6 +11,7 @@ from squeakserver.node.squeak_block_verifier import SqueakBlockVerifier
 from squeakserver.node.squeak_maker import SqueakMaker
 from squeakserver.node.squeak_rate_limiter import SqueakRateLimiter
 from squeakserver.node.squeak_whitelist import SqueakWhitelist
+from squeakserver.node.squeak_store import SqueakStore
 from squeakserver.server.buy_offer import BuyOffer
 from squeakserver.server.squeak_profile import SqueakProfile
 from squeakserver.server.squeak_subscription import SqueakSubscription
@@ -46,36 +47,25 @@ class SqueakNode:
             max_squeaks_per_address_per_hour,
         )
         self.squeak_whitelist = SqueakWhitelist(postgres_db,)
+        self.squeak_store = SqueakStore(
+            postgres_db,
+            self.squeak_block_verifier,
+            self.squeak_rate_limiter,
+            self.squeak_whitelist,
+        )
 
     def start_running(self):
         # self.squeak_block_periodic_worker.start_running()
         self.squeak_block_queue_worker.start_running()
 
-    def save_squeak(self, squeak):
-        if not self.squeak_whitelist.should_allow_squeak(squeak):
-            raise Exception("Squeak upload not allowed by whitelist.")
+    def save_uploaded_squeak(self, squeak):
+        return self.squeak_store.save_uploaded_squeak(squeak)
 
-        if not self.squeak_rate_limiter.should_rate_limit_allow(squeak):
-            raise Exception("Excedeed allowed number of squeaks per block.")
+    def save_created_squeak(self, squeak):
+        return self.squeak_store.save_created_squeak(squeak)
 
-        inserted_squeak_hash = self.postgres_db.insert_squeak(squeak)
-        self.squeak_block_verifier.add_squeak_to_queue(inserted_squeak_hash)
-        return inserted_squeak_hash
-
-    def save_squeak_and_verify(self, squeak):
-        if not self.squeak_rate_limiter.should_rate_limit_allow(squeak):
-            raise Exception("Excedeed allowed number of squeaks per block.")
-
-        inserted_squeak_hash = self.postgres_db.insert_squeak(squeak)
-        self.squeak_block_verifier.verify_squeak_block(inserted_squeak_hash)
-        return inserted_squeak_hash
-
-    def get_locked_squeak(self, squeak_hash):
-        squeak_entry = self.postgres_db.get_squeak_entry(squeak_hash)
-        squeak = squeak_entry.squeak
-        # Remove the decryption key before returning.
-        squeak.ClearDecryptionKey()
-        return squeak
+    def get_public_squeak(self, squeak_hash):
+        return self.squeak_store.get_public_squeak(squeak_hash)
 
     def get_squeak_entry(self, squeak_hash):
         return self.postgres_db.get_squeak_entry(squeak_hash)
@@ -179,28 +169,30 @@ class SqueakNode:
         squeak_profile = self.postgres_db.get_profile(profile_id)
         squeak_maker = SqueakMaker(self.lightning_client)
         squeak = squeak_maker.make_squeak(squeak_profile, content_str, replyto_hash)
-        return self.save_squeak_and_verify(squeak)
+        return self.save_created_squeak(squeak)
 
     def get_squeak_entry_with_profile(self, squeak_hash):
-        return self.postgres_db.get_squeak_entry_with_profile(squeak_hash)
+        return self.squeak_store.get_squeak_entry_with_profile(squeak_hash)
 
     def get_followed_squeak_entries_with_profile(self):
-        return self.postgres_db.get_followed_squeak_entries_with_profile()
+        return self.squeak_store.get_followed_squeak_entries_with_profile()
 
     def get_squeak_entries_with_profile_for_address(
         self, address, min_block, max_block
     ):
-        return self.postgres_db.get_squeak_entries_with_profile_for_address(
-            address, min_block, max_block,
+        return self.squeak_store.get_squeak_entries_with_profile_for_address(
+            address,
+            min_block,
+            max_block,
         )
 
     def get_ancestor_squeak_entries_with_profile(self, squeak_hash_str):
-        return self.postgres_db.get_thread_ancestor_squeak_entries_with_profile(
+        return self.squeak_store.get_ancestor_squeak_entries_with_profile(
             squeak_hash_str,
         )
 
     def delete_squeak(self, squeak_hash):
-        return self.postgres_db.delete_squeak(squeak_hash)
+        return self.squeak_store.delete_squeak(squeak_hash)
 
     def create_subscription(self, subscription_name, host, port):
         squeak_subscription = SqueakSubscription(

squeakserver/node/squeak_store.py

@@ -0,0 +1,55 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class SqueakStore:
+    def __init__(self, postgres_db, squeak_block_verifier, squeak_rate_limiter, squeak_whitelist):
+        self.postgres_db = postgres_db
+        self.squeak_block_verifier = squeak_block_verifier
+        self.squeak_rate_limiter = squeak_rate_limiter
+        self.squeak_whitelist = squeak_whitelist
+
+    def save_uploaded_squeak(self, squeak):
+        if not self.squeak_whitelist.should_allow_squeak(squeak):
+            raise Exception("Squeak upload not allowed by whitelist.")
+
+        if not self.squeak_rate_limiter.should_rate_limit_allow(squeak):
+            raise Exception("Excedeed allowed number of squeaks per block.")
+
+        inserted_squeak_hash = self.postgres_db.insert_squeak(squeak)
+        self.squeak_block_verifier.add_squeak_to_queue(inserted_squeak_hash)
+        return inserted_squeak_hash
+
+    def save_created_squeak(self, squeak):
+        inserted_squeak_hash = self.postgres_db.insert_squeak(squeak)
+        self.squeak_block_verifier.verify_squeak_block(inserted_squeak_hash)
+        return inserted_squeak_hash
+
+    def get_public_squeak(self, squeak_hash):
+        squeak_entry = self.postgres_db.get_squeak_entry(squeak_hash)
+        squeak = squeak_entry.squeak
+        # Remove the decryption key before returning.
+        squeak.ClearDecryptionKey()
+        return squeak
+
+    def get_squeak_entry_with_profile(self, squeak_hash):
+        return self.postgres_db.get_squeak_entry_with_profile(squeak_hash)
+
+    def get_followed_squeak_entries_with_profile(self):
+        return self.postgres_db.get_followed_squeak_entries_with_profile()
+
+    def get_squeak_entries_with_profile_for_address(
+        self, address, min_block, max_block
+    ):
+        return self.postgres_db.get_squeak_entries_with_profile_for_address(
+            address, min_block, max_block,
+        )
+
+    def get_ancestor_squeak_entries_with_profile(self, squeak_hash_str):
+        return self.postgres_db.get_thread_ancestor_squeak_entries_with_profile(
+            squeak_hash_str,
+        )
+
+    def delete_squeak(self, squeak_hash):
+        return self.postgres_db.delete_squeak(squeak_hash)

squeakserver/node/squeak_subscription_downloader.py

@@ -0,0 +1,9 @@
+import logging
+import queue
+
+logger = logging.getLogger(__name__)
+
+
+class SqueakSubscriptionDownloader:
+    def __init__(self):
+        pass

squeakserver/server/squeak_server_handler.py

@@ -16,11 +16,11 @@ class SqueakServerHandler(object):
     def handle_posted_squeak(self, squeak):
         logger.info("Handle posted squeak with hash: {}".format(get_hash(squeak).hex()))
         # Save the squeak
-        self.squeak_node.save_squeak(squeak)
+        self.squeak_node.save_uploaded_squeak(squeak)
 
     def handle_get_squeak(self, squeak_hash):
         logger.info("Handle get squeak by hash: {}".format(squeak_hash.hex()))
-        return self.squeak_node.get_locked_squeak(squeak_hash)
+        return self.squeak_node.get_public_squeak(squeak_hash)
 
     def handle_lookup_squeaks(self, addresses, min_block, max_block):
         logger.info(