GlcoinCore/squeaknode
1
0
Fork 0
mirror of https://github.com/yzernik/squeaknode.git synced 2026-08-15 12:50:47 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rename subscription (#192)

Browse source 
* Rename addserver request to createsubscription

* Rename server to subscription

* Show subscriptions in frontend
This commit is contained in:
Jonathan Zernik 2020-08-01 04:52:35 -07:00 • committed by GitHub
parent 3a0a322439
commit 874f27df58
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 174 additions and 160 deletions
Download patch file Download diff file Expand all files Collapse all files

16
frontend/squeak-node-frontend/src/components/CreateSubscriptionDialog/CreateSubscriptionDialog.js
View file

@ -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());
});
};

4
frontend/squeak-node-frontend/src/components/Layout/Layout.js
View file

@ -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) {
<Route path="/app/profile/:id" component={Profile} />
<Route path="/app/profiles" component={Profiles} />
<Route path="/app/lightning" component={Lightning} />
<Route path="/app/servers" component={Servers} />
<Route path="/app/subscriptions" component={Subscriptions} />
<Route path="/app/notifications" component={Notifications} />
<Route
exact

4
frontend/squeak-node-frontend/src/components/Sidebar/Sidebar.js
View file

@ -9,7 +9,7 @@ import {
LibraryBooks as LibraryIcon,
HelpOutline as FAQIcon,
ArrowBack as ArrowBackIcon,
CloudDownload as ServersIcon,
CloudDownload as SubscriptionIcon,
} from "@material-ui/icons";
import { useTheme } from "@material-ui/styles";
import { withRouter } from "react-router-dom";
@ -33,7 +33,7 @@ const structure = [
{ id: 0, label: "Timeline", link: "/app/timeline", icon: <HomeIcon /> },
{ id: 1, label: "Profiles", link: "/app/profiles", icon: <ProfilesIcon /> },
{ id: 2, label: "Lightning", link: "/app/lightning", icon: <LightningIcon /> },
{ id: 3, label: "Servers", link: "/app/servers", icon: <ServersIcon /> },
{ id: 3, label: "Subscriptions", link: "/app/subscriptions", icon: <SubscriptionIcon /> },
];
function Sidebar({ location }) {

6
frontend/squeak-node-frontend/src/pages/servers/package.json
View file

@ -1,6 +0,0 @@
{
"name": "Servers",
"version": "0.0.0",
"main": "Servers.js",
"private": true
}

25
frontend/squeak-node-frontend/src/pages/servers/Servers.js → frontend/squeak-node-frontend/src/pages/subscriptions/Subscriptions.js
View file

@ -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 (
<>
<Grid container spacing={4}>
{CreateServerButton()}
<Grid item xs={12}>
<MUIDataTable
title="Servers"
data={servers.map(p =>
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()}
< />);
}

6
frontend/squeak-node-frontend/src/pages/subscriptions/package.json Normal file
View file

@ -0,0 +1,6 @@
{
"name": "Subscriptions",
"version": "0.0.0",
"main": "Subscriptions.js",
"private": true
}

6
init.sql
View file

@ -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,

36
itests/tests/test_squeak_node.py
View file

@ -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

54
proto/squeak_admin.proto
View file

@ -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;

30
squeakserver/admin/squeak_admin_server_handler.py
View file

@ -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

61
squeakserver/admin/squeak_admin_server_servicer.py
View file

@ -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):

24
squeakserver/node/squeak_node.py
View file

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

52
squeakserver/server/postgres_db.py
View file

@ -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"],

5
squeakserver/server/squeak_server.py
View file

@ -1,5 +0,0 @@
from collections import namedtuple
SqueakServer = namedtuple(
"SqueakServer", "server_id, server_name, host, port, sharing, following",
)

5
squeakserver/server/squeak_subscription.py Normal file
View file

@ -0,0 +1,5 @@
from collections import namedtuple
SqueakSubscription = namedtuple(
"SqueakSubscription", "subscription_id, subscription_name, host, port, sharing, following",
)