diff --git a/frontend/squeak-node-frontend/src/components/CreateSubscriptionDialog/CreateSubscriptionDialog.js b/frontend/squeak-node-frontend/src/components/CreateSubscriptionDialog/CreateSubscriptionDialog.js index baf9ac9b..d18007f5 100644 --- a/frontend/squeak-node-frontend/src/components/CreateSubscriptionDialog/CreateSubscriptionDialog.js +++ b/frontend/squeak-node-frontend/src/components/CreateSubscriptionDialog/CreateSubscriptionDialog.js @@ -31,7 +31,7 @@ import SqueakThreadItem from "../../components/SqueakThreadItem"; import { CreateContactProfileRequest, - AddServerRequest, + CreateSubscriptionRequest, } from "../../proto/squeak_admin_pb" import {SqueakAdminClient} from "../../proto/squeak_admin_grpc_web_pb" @@ -56,24 +56,24 @@ export default function CreateSubscriptionDialog({ setHost(event.target.value); }; - const createSubscription = (serverName, host, port) => { + const createSubscription = (subscriptionName, host, port) => { console.log("called createContactProfile"); - var addServerRequest = new AddServerRequest() - addServerRequest.setServerName(serverName); - addServerRequest.setHost(host); + var createSubscriptionRequest = new CreateSubscriptionRequest() + createSubscriptionRequest.setSubscriptionName(subscriptionName); + createSubscriptionRequest.setHost(host); // TODO: use real port here // addServerRequest.setHost(0); - console.log(addServerRequest); + console.log(createSubscriptionRequest); - client.addServer(addServerRequest, {}, (err, response) => { + client.createSubscription(createSubscriptionRequest, {}, (err, response) => { if (err) { console.log(err.message); alert('Error creating subscription: ' + err.message); return; } console.log(response); - console.log(response.getServerId()); + console.log(response.getSubscriptionId()); // goToProfilePage(response.getProfileId()); }); }; diff --git a/frontend/squeak-node-frontend/src/components/Layout/Layout.js b/frontend/squeak-node-frontend/src/components/Layout/Layout.js index 16e3e539..0b56163f 100644 --- a/frontend/squeak-node-frontend/src/components/Layout/Layout.js +++ b/frontend/squeak-node-frontend/src/components/Layout/Layout.js @@ -26,7 +26,7 @@ import Maps from "../../pages/maps"; import Profiles from "../../pages/profiles"; import Icons from "../../pages/icons"; import Charts from "../../pages/charts"; -import Servers from "../../pages/servers"; +import Subscriptions from "../../pages/subscriptions"; // context import { useLayoutState } from "../../context/LayoutContext"; @@ -56,7 +56,7 @@ function Layout(props) { - + }, { id: 1, label: "Profiles", link: "/app/profiles", icon: }, { id: 2, label: "Lightning", link: "/app/lightning", icon: }, - { id: 3, label: "Servers", link: "/app/servers", icon: }, + { id: 3, label: "Subscriptions", link: "/app/subscriptions", icon: }, ]; function Sidebar({ location }) { diff --git a/frontend/squeak-node-frontend/src/pages/servers/package.json b/frontend/squeak-node-frontend/src/pages/servers/package.json deleted file mode 100644 index 83decde7..00000000 --- a/frontend/squeak-node-frontend/src/pages/servers/package.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "name": "Servers", - "version": "0.0.0", - "main": "Servers.js", - "private": true -} diff --git a/frontend/squeak-node-frontend/src/pages/servers/Servers.js b/frontend/squeak-node-frontend/src/pages/subscriptions/Subscriptions.js similarity index 85% rename from frontend/squeak-node-frontend/src/pages/servers/Servers.js rename to frontend/squeak-node-frontend/src/pages/subscriptions/Subscriptions.js index d5c65390..c6c25794 100644 --- a/frontend/squeak-node-frontend/src/pages/servers/Servers.js +++ b/frontend/squeak-node-frontend/src/pages/subscriptions/Subscriptions.js @@ -24,9 +24,8 @@ import CreateSubscriptionDialog from "../../components/CreateSubscriptionDialog" // data import mock from "../dashboard/mock"; -import {GetInfoRequest} from "../../proto/lnd_pb" import { - GetSqueakServersRequest, + GetSubscriptionsRequest, } from "../../proto/squeak_admin_pb" import {SqueakAdminClient} from "../../proto/squeak_admin_grpc_web_pb" @@ -40,9 +39,9 @@ const useStyles = makeStyles((theme) => ({ } })); -export default function Servers() { +export default function Subscriptions() { const classes = useStyles(); - const [servers, setServers] = useState([]); + const [subscriptions, setSubscriptions] = useState([]); const [createSubscriptionDialogOpen, setCreateSubscriptionDialogOpen] = useState(false); const history = useHistory(); @@ -56,15 +55,15 @@ export default function Servers() { const getSqueakServers = () => { console.log("called getSigningProfiles"); - var getSqueakServersRequest = new GetSqueakServersRequest() + var getSubscriptionsRequest = new GetSubscriptionsRequest(); - client.getSqueakServers(getSqueakServersRequest, {}, (err, response) => { + client.getSubscriptions(getSubscriptionsRequest, {}, (err, response) => { if (err) { console.log(err.message); return; } console.log(response); - setServers(response.getSqueakServersList()); + setSubscriptions(response.getSqueakSubscriptionsList()); }); }; @@ -97,18 +96,18 @@ export default function Servers() { ) } - function ServersInfo() { + function SubscriptionsInfo() { return ( <> {CreateServerButton()} + title="Subscriptions" + data={subscriptions.map(s => [ - p.getServerName(), - p.getHost(), + s.getSubscriptionName(), + s.getHost(), ] )} columns={["Name", "Host"]} @@ -142,7 +141,7 @@ export default function Servers() { return ( <> < PageTitle title = "Servers" /> - {ServersInfo()} + {SubscriptionsInfo()} {CreateServerDialogContent()} < />); } diff --git a/frontend/squeak-node-frontend/src/pages/subscriptions/package.json b/frontend/squeak-node-frontend/src/pages/subscriptions/package.json new file mode 100644 index 00000000..a4bbc198 --- /dev/null +++ b/frontend/squeak-node-frontend/src/pages/subscriptions/package.json @@ -0,0 +1,6 @@ +{ + "name": "Subscriptions", + "version": "0.0.0", + "main": "Subscriptions.js", + "private": true +} diff --git a/init.sql b/init.sql index 1db1ea9d..919d50c9 100644 --- a/init.sql +++ b/init.sql @@ -33,10 +33,10 @@ CREATE TABLE IF NOT EXISTS profile ( whitelisted BOOLEAN NOT NULL ); -CREATE TABLE IF NOT EXISTS server ( - server_id SERIAL PRIMARY KEY, +CREATE TABLE IF NOT EXISTS subscription ( + subscription_id SERIAL PRIMARY KEY, created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, - server_name VARCHAR(64), + subscription_name VARCHAR(64), server_host VARCHAR(256) NOT NULL, server_port INTEGER NOT NULL, sharing BOOLEAN NOT NULL, diff --git a/itests/tests/test_squeak_node.py b/itests/tests/test_squeak_node.py index d21a44ea..c767276a 100644 --- a/itests/tests/test_squeak_node.py +++ b/itests/tests/test_squeak_node.py @@ -442,26 +442,28 @@ def test_delete_squeak(server_stub, admin_stub, saved_squeak_hash): ) -def test_add_server(server_stub, admin_stub): - # Add a new server - add_server_response = admin_stub.AddServer( - squeak_admin_pb2.AddServerRequest(host="fake_host", port=1234,) +def test_create_subscription(server_stub, admin_stub): + # Add a new subscription + create_subscription_response = admin_stub.CreateSubscription( + squeak_admin_pb2.CreateSubscriptionRequest(host="fake_host", port=1234,) ) - server_id = add_server_response.server_id + subscription_id = create_subscription_response.subscription_id - # Get the new server - get_squeak_server_response = admin_stub.GetSqueakServer( - squeak_admin_pb2.GetSqueakServerRequest(server_id=server_id) + # Get the new subscription + get_subscription_response = admin_stub.GetSubscription( + squeak_admin_pb2.GetSubscriptionRequest( + subscription_id=subscription_id, + ) ) - assert get_squeak_server_response.squeak_server.host == "fake_host" - assert get_squeak_server_response.squeak_server.port == 1234 + assert get_subscription_response.squeak_subscription.host == "fake_host" + assert get_subscription_response.squeak_subscription.port == 1234 - # Get all servers - get_squeak_servers_response = admin_stub.GetSqueakServers( - squeak_admin_pb2.GetSqueakServersRequest() + # Get all subscriptions + get_subscriptions_response = admin_stub.GetSubscriptions( + squeak_admin_pb2.GetSubscriptionsRequest() ) - squeak_server_hosts = [ - server.host - for server in get_squeak_servers_response.squeak_servers + subscription_hosts = [ + squeak_subscription.host + for squeak_subscription in get_subscriptions_response.squeak_subscriptions ] - assert "fake_host" in squeak_server_hosts + assert "fake_host" in subscription_hosts diff --git a/proto/squeak_admin.proto b/proto/squeak_admin.proto index c8263ce2..c48f07eb 100644 --- a/proto/squeak_admin.proto +++ b/proto/squeak_admin.proto @@ -82,17 +82,17 @@ service SqueakAdmin { */ rpc DeleteSqueak (DeleteSqueakRequest) returns (DeleteSqueakReply) {} - /** sqkadmin: `addserver` + /** sqkadmin: `addsubscription` */ - rpc AddServer (AddServerRequest) returns (AddServerReply) {} + rpc CreateSubscription (CreateSubscriptionRequest) returns (CreateSubscriptionReply) {} - /** sqkadmin: `getsqueakserver` + /** sqkadmin: `getsubscription` */ - rpc GetSqueakServer (GetSqueakServerRequest) returns (GetSqueakServerReply) {} + rpc GetSubscription (GetSubscriptionRequest) returns (GetSubscriptionReply) {} - /** sqkadmin: `getsqueakservers` + /** sqkadmin: `getsubscriptions` */ - rpc GetSqueakServers (GetSqueakServersRequest) returns (GetSqueakServersReply) {} + rpc GetSubscriptions (GetSubscriptionsRequest) returns (GetSubscriptionsReply) {} } @@ -313,9 +313,9 @@ message DeleteSqueakRequest { message DeleteSqueakReply { } -message AddServerRequest { - /// Name of the server - string server_name = 1; +message CreateSubscriptionRequest { + /// Name of the subscription + string subscription_name = 1; /// Host string host = 2; @@ -324,35 +324,35 @@ message AddServerRequest { int32 port = 3; } -message AddServerReply { - /// The server id - int32 server_id = 1; +message CreateSubscriptionReply { + /// The subscription id + int32 subscription_id = 1; } -message GetSqueakServerRequest { - /// The server id - int32 server_id = 1; +message GetSubscriptionRequest { + /// The subscription id + int32 subscription_id = 1; } -message GetSqueakServerReply { - /// The server - SqueakServerSubscription squeak_server = 1; +message GetSubscriptionReply { + /// The subscription + SqueakSubscription squeak_subscription = 1; } -message GetSqueakServersRequest { +message GetSubscriptionsRequest { } -message GetSqueakServersReply { - /// The servers - repeated SqueakServerSubscription squeak_servers = 1; +message GetSubscriptionsReply { + /// The subscriptions + repeated SqueakSubscription squeak_subscriptions = 1; } -message SqueakServerSubscription { - /// The server id - int32 server_id = 1; +message SqueakSubscription { + /// The subscription id + int32 subscription_id = 1; - /// The server name - string server_name = 2; + /// The subscription name + string subscription_name = 2; /// Host string host = 3; diff --git a/squeakserver/admin/squeak_admin_server_handler.py b/squeakserver/admin/squeak_admin_server_handler.py index b3713796..920d470c 100644 --- a/squeakserver/admin/squeak_admin_server_handler.py +++ b/squeakserver/admin/squeak_admin_server_handler.py @@ -153,21 +153,25 @@ class SqueakAdminServerHandler(object): self.squeak_node.delete_squeak(squeak_hash) logger.info("Deleted squeak entry with hash: {}".format(squeak_hash)) - def handle_add_server(self, server_name, server_host, server_port): + def handle_create_subscription(self, subscription_name, host, port): logger.info( - "Handle add server with name: {}, host: {}, port: {}".format( - server_name, server_host, server_port, + "Handle create subscription with name: {}, host: {}, port: {}".format( + subscription_name, host, port, ) ) - server_id = self.squeak_node.add_server(server_name, server_host, server_port,) - return server_id + subscription_id = self.squeak_node.create_subscription( + subscription_name, + host, + port, + ) + return subscription_id - def handle_get_squeak_server(self, server_id): - logger.info("Handle get squeak server with id: {}".format(server_id)) - squeak_server = self.squeak_node.get_squeak_server(server_id) - return squeak_server + def handle_get_squeak_subscription(self, subscription_id): + logger.info("Handle get squeak subscription with id: {}".format(subscription_id)) + squeak_subscription = self.squeak_node.get_subscription(subscription_id) + return squeak_subscription - def handle_get_squeak_servers(self): - logger.info("Handle get squeak servers") - squeak_servers = self.squeak_node.get_squeak_servers() - return squeak_servers + def handle_get_squeak_subscriptions(self): + logger.info("Handle get squeak subscriptions") + squeak_subscriptions = self.squeak_node.get_subscriptions() + return squeak_subscriptions diff --git a/squeakserver/admin/squeak_admin_server_servicer.py b/squeakserver/admin/squeak_admin_server_servicer.py index 97adf3d7..aa218bdf 100644 --- a/squeakserver/admin/squeak_admin_server_servicer.py +++ b/squeakserver/admin/squeak_admin_server_servicer.py @@ -152,27 +152,36 @@ class SqueakAdminServerServicer(squeak_admin_pb2_grpc.SqueakAdminServicer): self.handler.handle_delete_squeak(squeak_hash) return squeak_admin_pb2.DeleteSqueakReply() - def AddServer(self, request, context): - server_name = request.server_name if request.server_name else None - server_host = request.host - server_port = request.port - server_id = self.handler.handle_add_server( - server_name, server_host, server_port, + def CreateSubscription(self, request, context): + subscription_name = request.subscription_name if request.subscription_name else None + host = request.host + port = request.port + subscription_id = self.handler.handle_create_subscription( + subscription_name, + host, + port, + ) + return squeak_admin_pb2.CreateSubscriptionReply( + subscription_id=subscription_id, ) - return squeak_admin_pb2.AddServerReply(server_id=server_id) - def GetSqueakServer(self, request, context): - server_id = request.server_id - squeak_server = self.handler.handle_get_squeak_server(server_id) - squeak_server_msg = self._squeak_server_to_message(squeak_server) - return squeak_admin_pb2.GetSqueakServerReply(squeak_server=squeak_server_msg) + def GetSubscription(self, request, context): + subscription_id = request.subscription_id + squeak_subscription = self.handler.handle_get_squeak_subscription(subscription_id) + squeak_subscription_msg = self._squeak_subscription_to_message(squeak_subscription) + return squeak_admin_pb2.GetSubscriptionReply( + squeak_subscription=squeak_subscription_msg, + ) - def GetSqueakServers(self, request, context): - squeak_servers = self.handler.handle_get_squeak_servers() - squeak_server_msgs = [ - self._squeak_server_to_message(squeak_server) for squeak_server in squeak_servers + def GetSubscriptions(self, request, context): + squeak_subscriptions = self.handler.handle_get_squeak_subscriptions() + squeak_subscription_msgs = [ + self._squeak_subscription_to_message(squeak_subscription) + for squeak_subscription in squeak_subscriptions ] - return squeak_admin_pb2.GetSqueakServersReply(squeak_servers=squeak_server_msgs) + return squeak_admin_pb2.GetSubscriptionsReply( + squeak_subscriptions=squeak_subscription_msgs, + ) def _squeak_entry_to_message(self, squeak_entry_with_profile): if squeak_entry_with_profile is None: @@ -215,16 +224,16 @@ class SqueakAdminServerServicer(squeak_admin_pb2_grpc.SqueakAdminServicer): whitelisted=squeak_profile.whitelisted, ) - def _squeak_server_to_message(self, squeak_server): - if squeak_server is None: + def _squeak_subscription_to_message(self, squeak_subscription): + if squeak_subscription is None: return None - return squeak_admin_pb2.SqueakServerSubscription( - server_id=squeak_server.server_id, - server_name=squeak_server.server_name, - host=squeak_server.host, - port=squeak_server.port, - sharing=squeak_server.sharing, - following=squeak_server.following, + return squeak_admin_pb2.SqueakSubscription( + subscription_id=squeak_subscription.subscription_id, + subscription_name=squeak_subscription.subscription_name, + host=squeak_subscription.host, + port=squeak_subscription.port, + sharing=squeak_subscription.sharing, + following=squeak_subscription.following, ) def serve(self): diff --git a/squeakserver/node/squeak_node.py b/squeakserver/node/squeak_node.py index f3f374d5..69beaab1 100644 --- a/squeakserver/node/squeak_node.py +++ b/squeakserver/node/squeak_node.py @@ -13,7 +13,7 @@ from squeakserver.node.squeak_rate_limiter import SqueakRateLimiter from squeakserver.node.squeak_whitelist import SqueakWhitelist from squeakserver.server.buy_offer import BuyOffer from squeakserver.server.squeak_profile import SqueakProfile -from squeakserver.server.squeak_server import SqueakServer +from squeakserver.server.squeak_subscription import SqueakSubscription from squeakserver.server.util import generate_offer_preimage @@ -202,19 +202,19 @@ class SqueakNode: def delete_squeak(self, squeak_hash): return self.postgres_db.delete_squeak(squeak_hash) - def add_server(self, server_name, server_host, server_port): - squeak_server = SqueakServer( - server_id=None, - server_name=server_name, - host=server_host, - port=server_port, + def create_subscription(self, subscription_name, host, port): + squeak_subscription = SqueakSubscription( + subscription_id=None, + subscription_name=subscription_name, + host=host, + port=port, sharing=False, following=False, ) - return self.postgres_db.insert_server(squeak_server) + return self.postgres_db.insert_subscription(squeak_subscription) - def get_squeak_server(self, server_id): - return self.postgres_db.get_server(server_id) + def get_subscription(self, subscription_id): + return self.postgres_db.get_subscription(subscription_id) - def get_squeak_servers(self): - return self.postgres_db.get_servers() + def get_subscriptions(self): + return self.postgres_db.get_subscriptions() diff --git a/squeakserver/server/postgres_db.py b/squeakserver/server/postgres_db.py index 1549294b..38ddac42 100644 --- a/squeakserver/server/postgres_db.py +++ b/squeakserver/server/postgres_db.py @@ -10,7 +10,7 @@ from squeakserver.blockchain.util import parse_block_header from squeakserver.core.squeak_entry import SqueakEntry from squeakserver.core.squeak_entry_with_profile import SqueakEntryWithProfile from squeakserver.server.squeak_profile import SqueakProfile -from squeakserver.server.squeak_server import SqueakServer +from squeakserver.server.squeak_subscription import SqueakSubscription from squeakserver.server.util import get_hash logger = logging.getLogger(__name__) @@ -370,49 +370,49 @@ class PostgresDb: with self.get_cursor() as curs: curs.execute(sql, (squeak_hash_str,)) - def insert_server(self, squeak_server): - """ Insert a new squeak server. """ + def insert_subscription(self, squeak_subscription): + """ Insert a new squeak subscription. """ sql = """ - INSERT INTO server(server_name, server_host, server_port, sharing, following) + INSERT INTO subscription(subscription_name, server_host, server_port, sharing, following) VALUES(%s, %s, %s, %s, %s) - RETURNING server_id; + RETURNING subscription_id; """ with self.get_cursor() as curs: # execute the INSERT statement curs.execute( sql, ( - squeak_server.server_name, - squeak_server.host, - squeak_server.port, - squeak_server.sharing, - squeak_server.following, + squeak_subscription.subscription_name, + squeak_subscription.host, + squeak_subscription.port, + squeak_subscription.sharing, + squeak_subscription.following, ), ) - # get the new server id back + # get the new subscription id back row = curs.fetchone() - return row["server_id"] + return row["subscription_id"] - def get_server(self, server_id): - """ Get a server. """ + def get_subscription(self, subscription_id): + """ Get a subscription. """ sql = """ - SELECT * FROM server WHERE server_id=%s""" + SELECT * FROM subscription WHERE subscription_id=%s""" with self.get_cursor() as curs: - curs.execute(sql, (server_id,)) + curs.execute(sql, (subscription_id,)) row = curs.fetchone() - return self._parse_squeak_server(row) + return self._parse_squeak_subscription(row) - def get_servers(self): - """ Get all servers. """ + def get_subscriptions(self): + """ Get all subscriptions. """ sql = """ - SELECT * FROM server; + SELECT * FROM subscription; """ with self.get_cursor() as curs: curs.execute(sql) rows = curs.fetchall() - servers = [self._parse_squeak_server(row) for row in rows] - return servers + subscriptions = [self._parse_squeak_subscription(row) for row in rows] + return subscriptions def _parse_squeak_entry(self, row): vch_decryption_key_column = row["vch_decryption_key"] @@ -466,12 +466,12 @@ class PostgresDb: squeak_entry=squeak_entry, squeak_profile=squeak_profile, ) - def _parse_squeak_server(self, row): + def _parse_squeak_subscription(self, row): if row is None: return None - return SqueakServer( - server_id=row["server_id"], - server_name=row["server_name"], + return SqueakSubscription( + subscription_id=row["subscription_id"], + subscription_name=row["subscription_name"], host=row["server_host"], port=row["server_port"], sharing=row["sharing"], diff --git a/squeakserver/server/squeak_server.py b/squeakserver/server/squeak_server.py deleted file mode 100644 index 8cfc4143..00000000 --- a/squeakserver/server/squeak_server.py +++ /dev/null @@ -1,5 +0,0 @@ -from collections import namedtuple - -SqueakServer = namedtuple( - "SqueakServer", "server_id, server_name, host, port, sharing, following", -) diff --git a/squeakserver/server/squeak_subscription.py b/squeakserver/server/squeak_subscription.py new file mode 100644 index 00000000..84492d41 --- /dev/null +++ b/squeakserver/server/squeak_subscription.py @@ -0,0 +1,5 @@ +from collections import namedtuple + +SqueakSubscription = namedtuple( + "SqueakSubscription", "subscription_id, subscription_name, host, port, sharing, following", +)